packages feed

ghc-lib-parser 0.20200401 → 0.20200501

raw patch · 325 files changed

+61748/−61462 lines, 325 filesdep ~basedep ~ghc-prim

Dependency ranges changed: base, ghc-prim

Files

+ compiler/GHC/Builtin/Names.hs view
@@ -0,0 +1,2496 @@+{-+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++\section[GHC.Builtin.Names]{Definitions of prelude modules and names}+++Nota Bene: all Names defined in here should come from the base package++ - ModuleNames for prelude modules,+        e.g.    pREL_BASE_Name :: ModuleName++ - Modules for prelude modules+        e.g.    pREL_Base :: Module++ - Uniques for Ids, DataCons, TyCons and Classes that the compiler+   "knows about" in some way+        e.g.    intTyConKey :: Unique+                minusClassOpKey :: Unique++ - Names for Ids, DataCons, TyCons and Classes that the compiler+   "knows about" in some way+        e.g.    intTyConName :: Name+                minusName    :: Name+   One of these Names contains+        (a) the module and occurrence name of the thing+        (b) its Unique+   The way the compiler "knows about" one of these things is+   where the type checker or desugarer needs to look it up. For+   example, when desugaring list comprehensions the desugarer+   needs to conjure up 'foldr'.  It does this by looking up+   foldrName in the environment.++ - RdrNames for Ids, DataCons etc that the compiler may emit into+   generated code (e.g. for deriving).  It's not necessary to know+   the uniques for these guys, only their names+++Note [Known-key names]+~~~~~~~~~~~~~~~~~~~~~~+It is *very* important that the compiler gives wired-in things and+things with "known-key" names the correct Uniques wherever they+occur. We have to be careful about this in exactly two places:++  1. When we parse some source code, renaming the AST better yield an+     AST whose Names have the correct uniques++  2. When we read an interface file, the read-in gubbins better have+     the right uniques++This is accomplished through a combination of mechanisms:++  1. When parsing source code, the RdrName-decorated AST has some+     RdrNames which are Exact. These are wired-in RdrNames where the+     we could directly tell from the parsed syntax what Name to+     use. For example, when we parse a [] in a type we can just insert+     an Exact RdrName Name with the listTyConKey.++     Currently, I believe this is just an optimisation: it would be+     equally valid to just output Orig RdrNames that correctly record+     the module etc we expect the final Name to come from. However,+     were we to eliminate isBuiltInOcc_maybe it would become essential+     (see point 3).++  2. The knownKeyNames (which consist of the basicKnownKeyNames from+     the module, and those names reachable via the wired-in stuff from+     GHC.Builtin.Types) are used to initialise the "OrigNameCache" in+     GHC.Iface.Env.  This initialization ensures that when the type checker+     or renamer (both of which use GHC.Iface.Env) look up an original name+     (i.e. a pair of a Module and an OccName) for a known-key name+     they get the correct Unique.++     This is the most important mechanism for ensuring that known-key+     stuff gets the right Unique, and is why it is so important to+     place your known-key names in the appropriate lists.++  3. For "infinite families" of known-key names (i.e. tuples and sums), we+     have to be extra careful. Because there are an infinite number of+     these things, we cannot add them to the list of known-key names+     used to initialise the OrigNameCache. Instead, we have to+     rely on never having to look them up in that cache. See+     Note [Infinite families of known-key names] for details.+++Note [Infinite families of known-key names]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Infinite families of known-key things (e.g. tuples and sums) pose a tricky+problem: we can't add them to the knownKeyNames finite map which we use to+ensure that, e.g., a reference to (,) gets assigned the right unique (if this+doesn't sound familiar see Note [Known-key names] above).++We instead handle tuples and sums separately from the "vanilla" known-key+things,++  a) The parser recognises them specially and generates an Exact Name (hence not+     looked up in the orig-name cache)++  b) The known infinite families of names are specially serialised by+     GHC.Iface.Binary.putName, with that special treatment detected when we read+     back to ensure that we get back to the correct uniques. See Note [Symbol+     table representation of names] in GHC.Iface.Binary and Note [How tuples+     work] in GHC.Builtin.Types.++Most of the infinite families cannot occur in source code, so mechanisms (a) and (b)+suffice to ensure that they always have the right Unique. In particular,+implicit param TyCon names, constraint tuples and Any TyCons cannot be mentioned+by the user. For those things that *can* appear in source programs,++  c) GHC.Iface.Env.lookupOrigNameCache uses isBuiltInOcc_maybe to map built-in syntax+     directly onto the corresponding name, rather than trying to find it in the+     original-name cache.++     See also Note [Built-in syntax and the OrigNameCache]++Note that one-tuples are an exception to the rule, as they do get assigned+known keys. See+Note [One-tuples] (Wrinkle: Make boxed one-tuple names have known keys)+in GHC.Builtin.Types.++Note [The integer library]+~~~~~~~~~~~~~~~~~~~~~~~~~~++Clearly, we need to know the names of various definitions of the integer+library, e.g. the type itself, `mkInteger` etc. But there are two possible+implementations of the integer library:++ * integer-gmp (fast, but uses libgmp, which may not be available on all+   targets and is GPL licensed)+ * integer-simple (slow, but pure Haskell and BSD-licensed)++We want the compiler to work with either one. The way we achieve this is:++ * When compiling the integer-{gmp,simple} library, we pass+     -this-unit-id  integer-wired-in+   to GHC (see the cabal file libraries/integer-{gmp,simple}.+ * This way, GHC can use just this UnitID (see Module.integerUnitId) when+   generating code, and the linker will succeed.++Unfortuately, the abstraction is not complete: When using integer-gmp, we+really want to use the S# constructor directly. This is controlled by+the `integerLibrary` field of `DynFlags`: If it is IntegerGMP, we use+this constructor directly (see  CorePrep.lookupIntegerSDataConName)++When GHC reads the package data base, it (internally only) pretends it has UnitId+`integer-wired-in` instead of the actual UnitId (which includes the version+number); just like for `base` and other packages, as described in+Note [Wired-in units] in GHC.Unit.Module. This is done in+GHC.Unit.State.findWiredInPackages.+-}++{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}++module GHC.Builtin.Names+   ( Unique, Uniquable(..), hasKey,  -- Re-exported for convenience++   -----------------------------------------------------------+   module GHC.Builtin.Names, -- A huge bunch of (a) Names,  e.g. intTyConName+                             --                 (b) Uniques e.g. intTyConKey+                             --                 (c) Groups of classes and types+                             --                 (d) miscellaneous things+                             -- So many that we export them all+   )+where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Unit.Types+import GHC.Unit.Module.Name+import GHC.Types.Name.Occurrence+import GHC.Types.Name.Reader+import GHC.Types.Unique+import GHC.Types.Name+import GHC.Types.SrcLoc+import GHC.Data.FastString++{-+************************************************************************+*                                                                      *+     allNameStrings+*                                                                      *+************************************************************************+-}++allNameStrings :: [String]+-- Infinite list of a,b,c...z, aa, ab, ac, ... etc+allNameStrings = [ c:cs | cs <- "" : allNameStrings, c <- ['a'..'z'] ]++{-+************************************************************************+*                                                                      *+\subsection{Local Names}+*                                                                      *+************************************************************************++This *local* name is used by the interactive stuff+-}++itName :: Unique -> SrcSpan -> Name+itName uniq loc = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) loc++-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly+-- during compiler debugging.+mkUnboundName :: OccName -> Name+mkUnboundName occ = mkInternalName unboundKey occ noSrcSpan++isUnboundName :: Name -> Bool+isUnboundName name = name `hasKey` unboundKey++{-+************************************************************************+*                                                                      *+\subsection{Known key Names}+*                                                                      *+************************************************************************++This section tells what the compiler knows about the association of+names with uniques.  These ones are the *non* wired-in ones.  The+wired in ones are defined in GHC.Builtin.Types etc.+-}++basicKnownKeyNames :: [Name]  -- See Note [Known-key names]+basicKnownKeyNames+ = genericTyConNames+ ++ [   --  Classes.  *Must* include:+        --      classes that are grabbed by key (e.g., eqClassKey)+        --      classes in "Class.standardClassKeys" (quite a few)+        eqClassName,                    -- mentioned, derivable+        ordClassName,                   -- derivable+        boundedClassName,               -- derivable+        numClassName,                   -- mentioned, numeric+        enumClassName,                  -- derivable+        monadClassName,+        functorClassName,+        realClassName,                  -- numeric+        integralClassName,              -- numeric+        fractionalClassName,            -- numeric+        floatingClassName,              -- numeric+        realFracClassName,              -- numeric+        realFloatClassName,             -- numeric+        dataClassName,+        isStringClassName,+        applicativeClassName,+        alternativeClassName,+        foldableClassName,+        traversableClassName,+        semigroupClassName, sappendName,+        monoidClassName, memptyName, mappendName, mconcatName,++        -- The IO type+        -- See Note [TyConRepNames for non-wired-in TyCons]+        ioTyConName, ioDataConName,+        runMainIOName,+        runRWName,++        -- Type representation types+        trModuleTyConName, trModuleDataConName,+        trNameTyConName, trNameSDataConName, trNameDDataConName,+        trTyConTyConName, trTyConDataConName,++        -- Typeable+        typeableClassName,+        typeRepTyConName,+        someTypeRepTyConName,+        someTypeRepDataConName,+        kindRepTyConName,+        kindRepTyConAppDataConName,+        kindRepVarDataConName,+        kindRepAppDataConName,+        kindRepFunDataConName,+        kindRepTYPEDataConName,+        kindRepTypeLitSDataConName,+        kindRepTypeLitDDataConName,+        typeLitSortTyConName,+        typeLitSymbolDataConName,+        typeLitNatDataConName,+        typeRepIdName,+        mkTrTypeName,+        mkTrConName,+        mkTrAppName,+        mkTrFunName,+        typeSymbolTypeRepName, typeNatTypeRepName,+        trGhcPrimModuleName,++        -- KindReps for common cases+        starKindRepName,+        starArrStarKindRepName,+        starArrStarArrStarKindRepName,++        -- Dynamic+        toDynName,++        -- Numeric stuff+        negateName, minusName, geName, eqName,++        -- Conversion functions+        rationalTyConName,+        ratioTyConName, ratioDataConName,+        fromRationalName, fromIntegerName,+        toIntegerName, toRationalName,+        fromIntegralName, realToFracName,++        -- Int# stuff+        divIntName, modIntName,++        -- String stuff+        fromStringName,++        -- Enum stuff+        enumFromName, enumFromThenName,+        enumFromThenToName, enumFromToName,++        -- Applicative stuff+        pureAName, apAName, thenAName,++        -- Functor stuff+        fmapName,++        -- Monad stuff+        thenIOName, bindIOName, returnIOName, failIOName, bindMName, thenMName,+        returnMName, joinMName,++        -- MonadFail+        monadFailClassName, failMName,++        -- MonadFix+        monadFixClassName, mfixName,++        -- Arrow stuff+        arrAName, composeAName, firstAName,+        appAName, choiceAName, loopAName,++        -- Ix stuff+        ixClassName,++        -- Show stuff+        showClassName,++        -- Read stuff+        readClassName,++        -- Stable pointers+        newStablePtrName,++        -- GHC Extensions+        groupWithName,++        -- Strings and lists+        unpackCStringName,+        unpackCStringFoldrName, unpackCStringUtf8Name,++        -- Overloaded lists+        isListClassName,+        fromListName,+        fromListNName,+        toListName,++        -- List operations+        concatName, filterName, mapName,+        zipName, foldrName, buildName, augmentName, appendName,++        -- FFI primitive types that are not wired-in.+        stablePtrTyConName, ptrTyConName, funPtrTyConName,+        int8TyConName, int16TyConName, int32TyConName, int64TyConName,+        word16TyConName, word32TyConName, word64TyConName,++        -- Others+        otherwiseIdName, inlineIdName,+        eqStringName, assertName, breakpointName, breakpointCondName,+        opaqueTyConName,+        assertErrorName, traceName,+        printName, fstName, sndName,+        dollarName,++        -- Integer+        integerTyConName, mkIntegerName,+        integerToWord64Name, integerToInt64Name,+        word64ToIntegerName, int64ToIntegerName,+        plusIntegerName, timesIntegerName, smallIntegerName,+        wordToIntegerName,+        integerToWordName, integerToIntName, minusIntegerName,+        negateIntegerName, eqIntegerPrimName, neqIntegerPrimName,+        absIntegerName, signumIntegerName,+        leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,+        compareIntegerName, quotRemIntegerName, divModIntegerName,+        quotIntegerName, remIntegerName, divIntegerName, modIntegerName,+        floatFromIntegerName, doubleFromIntegerName,+        encodeFloatIntegerName, encodeDoubleIntegerName,+        decodeDoubleIntegerName,+        gcdIntegerName, lcmIntegerName,+        andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,+        shiftLIntegerName, shiftRIntegerName, bitIntegerName,+        integerSDataConName,naturalSDataConName,++        -- Natural+        naturalTyConName,+        naturalFromIntegerName, naturalToIntegerName,+        plusNaturalName, minusNaturalName, timesNaturalName, mkNaturalName,+        wordToNaturalName,++        -- Float/Double+        rationalToFloatName,+        rationalToDoubleName,++        -- Other classes+        randomClassName, randomGenClassName, monadPlusClassName,++        -- Type-level naturals+        knownNatClassName, knownSymbolClassName,++        -- Overloaded labels+        isLabelClassName,++        -- Implicit Parameters+        ipClassName,++        -- Overloaded record fields+        hasFieldClassName,++        -- Call Stacks+        callStackTyConName,+        emptyCallStackName, pushCallStackName,++        -- Source Locations+        srcLocDataConName,++        -- Annotation type checking+        toAnnotationWrapperName++        -- The Ordering type+        , orderingTyConName+        , ordLTDataConName, ordEQDataConName, ordGTDataConName++        -- The SPEC type for SpecConstr+        , specTyConName++        -- The Either type+        , eitherTyConName, leftDataConName, rightDataConName++        -- Plugins+        , pluginTyConName+        , frontendPluginTyConName++        -- Generics+        , genClassName, gen1ClassName+        , datatypeClassName, constructorClassName, selectorClassName++        -- Monad comprehensions+        , guardMName+        , liftMName+        , mzipName++        -- GHCi Sandbox+        , ghciIoClassName, ghciStepIoMName++        -- StaticPtr+        , makeStaticName+        , staticPtrTyConName+        , staticPtrDataConName, staticPtrInfoDataConName+        , fromStaticPtrName++        -- Fingerprint+        , fingerprintDataConName++        -- Custom type errors+        , errorMessageTypeErrorFamName+        , typeErrorTextDataConName+        , typeErrorAppendDataConName+        , typeErrorVAppendDataConName+        , typeErrorShowTypeDataConName++        -- Unsafe coercion proofs+        , unsafeEqualityProofName+        , unsafeEqualityTyConName+        , unsafeReflDataConName+        , unsafeCoercePrimName+        , unsafeCoerceName+    ]++genericTyConNames :: [Name]+genericTyConNames = [+    v1TyConName, u1TyConName, par1TyConName, rec1TyConName,+    k1TyConName, m1TyConName, sumTyConName, prodTyConName,+    compTyConName, rTyConName, dTyConName,+    cTyConName, sTyConName, rec0TyConName,+    d1TyConName, c1TyConName, s1TyConName, noSelTyConName,+    repTyConName, rep1TyConName, uRecTyConName,+    uAddrTyConName, uCharTyConName, uDoubleTyConName,+    uFloatTyConName, uIntTyConName, uWordTyConName,+    prefixIDataConName, infixIDataConName, leftAssociativeDataConName,+    rightAssociativeDataConName, notAssociativeDataConName,+    sourceUnpackDataConName, sourceNoUnpackDataConName,+    noSourceUnpackednessDataConName, sourceLazyDataConName,+    sourceStrictDataConName, noSourceStrictnessDataConName,+    decidedLazyDataConName, decidedStrictDataConName, decidedUnpackDataConName,+    metaDataDataConName, metaConsDataConName, metaSelDataConName+  ]++{-+************************************************************************+*                                                                      *+\subsection{Module names}+*                                                                      *+************************************************************************+++--MetaHaskell Extension Add a new module here+-}++pRELUDE :: Module+pRELUDE         = mkBaseModule_ pRELUDE_NAME++gHC_PRIM, gHC_TYPES, gHC_GENERICS, gHC_MAGIC,+    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_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,+    gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC,+    tYPEABLE, tYPEABLE_INTERNAL, gENERICS,+    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, uNSAFE_COERCE :: Module++gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values+gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")+gHC_MAGIC       = mkPrimModule (fsLit "GHC.Magic")+gHC_CSTRING     = mkPrimModule (fsLit "GHC.CString")+gHC_CLASSES     = mkPrimModule (fsLit "GHC.Classes")+gHC_PRIMOPWRAPPERS = mkPrimModule (fsLit "GHC.PrimopWrappers")++gHC_BASE        = mkBaseModule (fsLit "GHC.Base")+gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")+gHC_GHCI        = mkBaseModule (fsLit "GHC.GHCi")+gHC_GHCI_HELPERS= mkBaseModule (fsLit "GHC.GHCi.Helpers")+gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")+gHC_READ        = mkBaseModule (fsLit "GHC.Read")+gHC_NUM         = mkBaseModule (fsLit "GHC.Num")+gHC_MAYBE       = mkBaseModule (fsLit "GHC.Maybe")+gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")+gHC_NATURAL     = mkBaseModule (fsLit "GHC.Natural")+gHC_LIST        = mkBaseModule (fsLit "GHC.List")+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")+gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")+gHC_IO          = mkBaseModule (fsLit "GHC.IO")+gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")+gHC_ST          = mkBaseModule (fsLit "GHC.ST")+gHC_IX          = mkBaseModule (fsLit "GHC.Ix")+gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")+gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")+gHC_ERR         = mkBaseModule (fsLit "GHC.Err")+gHC_REAL        = mkBaseModule (fsLit "GHC.Real")+gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")+gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")+sYSTEM_IO       = mkBaseModule (fsLit "System.IO")+dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")+tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")+tYPEABLE_INTERNAL = mkBaseModule (fsLit "Data.Typeable.Internal")+gENERICS        = mkBaseModule (fsLit "Data.Data")+rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")+lEX             = mkBaseModule (fsLit "Text.Read.Lex")+gHC_INT         = mkBaseModule (fsLit "GHC.Int")+gHC_WORD        = mkBaseModule (fsLit "GHC.Word")+mONAD           = mkBaseModule (fsLit "Control.Monad")+mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")+mONAD_ZIP       = mkBaseModule (fsLit "Control.Monad.Zip")+mONAD_FAIL      = mkBaseModule (fsLit "Control.Monad.Fail")+aRROW           = mkBaseModule (fsLit "Control.Arrow")+cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")+gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")+rANDOM          = mkBaseModule (fsLit "System.Random")+gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")+cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")+gHC_GENERICS    = mkBaseModule (fsLit "GHC.Generics")+gHC_TYPELITS    = mkBaseModule (fsLit "GHC.TypeLits")+gHC_TYPENATS    = mkBaseModule (fsLit "GHC.TypeNats")+dATA_TYPE_EQUALITY = mkBaseModule (fsLit "Data.Type.Equality")+dATA_COERCE     = mkBaseModule (fsLit "Data.Coerce")+dEBUG_TRACE     = mkBaseModule (fsLit "Debug.Trace")+uNSAFE_COERCE   = mkBaseModule (fsLit "Unsafe.Coerce")++gHC_SRCLOC :: Module+gHC_SRCLOC = mkBaseModule (fsLit "GHC.SrcLoc")++gHC_STACK, gHC_STACK_TYPES :: Module+gHC_STACK = mkBaseModule (fsLit "GHC.Stack")+gHC_STACK_TYPES = mkBaseModule (fsLit "GHC.Stack.Types")++gHC_STATICPTR :: Module+gHC_STATICPTR = mkBaseModule (fsLit "GHC.StaticPtr")++gHC_STATICPTR_INTERNAL :: Module+gHC_STATICPTR_INTERNAL = mkBaseModule (fsLit "GHC.StaticPtr.Internal")++gHC_FINGERPRINT_TYPE :: Module+gHC_FINGERPRINT_TYPE = mkBaseModule (fsLit "GHC.Fingerprint.Type")++gHC_OVER_LABELS :: Module+gHC_OVER_LABELS = mkBaseModule (fsLit "GHC.OverloadedLabels")++gHC_RECORDS :: Module+gHC_RECORDS = mkBaseModule (fsLit "GHC.Records")++mAIN, rOOT_MAIN :: Module+mAIN            = mkMainModule_ mAIN_NAME+rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation++mkInteractiveModule :: Int -> Module+-- (mkInteractiveMoudule 9) makes module 'interactive:M9'+mkInteractiveModule n = mkModule interactiveUnitId (mkModuleName ("Ghci" ++ show n))++pRELUDE_NAME, mAIN_NAME :: ModuleName+pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")+mAIN_NAME      = mkModuleNameFS (fsLit "Main")++dATA_ARRAY_PARALLEL_NAME, dATA_ARRAY_PARALLEL_PRIM_NAME :: ModuleName+dATA_ARRAY_PARALLEL_NAME      = mkModuleNameFS (fsLit "Data.Array.Parallel")+dATA_ARRAY_PARALLEL_PRIM_NAME = mkModuleNameFS (fsLit "Data.Array.Parallel.Prim")++mkPrimModule :: FastString -> Module+mkPrimModule m = mkModule primUnitId (mkModuleNameFS m)++mkIntegerModule :: FastString -> Module+mkIntegerModule m = mkModule integerUnitId (mkModuleNameFS m)++mkBaseModule :: FastString -> Module+mkBaseModule m = mkModule baseUnitId (mkModuleNameFS m)++mkBaseModule_ :: ModuleName -> Module+mkBaseModule_ m = mkModule baseUnitId m++mkThisGhcModule :: FastString -> Module+mkThisGhcModule m = mkModule thisGhcUnitId (mkModuleNameFS m)++mkThisGhcModule_ :: ModuleName -> Module+mkThisGhcModule_ m = mkModule thisGhcUnitId m++mkMainModule :: FastString -> Module+mkMainModule m = mkModule mainUnitId (mkModuleNameFS m)++mkMainModule_ :: ModuleName -> Module+mkMainModule_ m = mkModule mainUnitId m++{-+************************************************************************+*                                                                      *+                        RdrNames+*                                                                      *+************************************************************************+-}++main_RDR_Unqual    :: RdrName+main_RDR_Unqual = mkUnqual varName (fsLit "main")+        -- We definitely don't want an Orig RdrName, because+        -- main might, in principle, be imported into module Main++eq_RDR, ge_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,+    ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName+eq_RDR                  = nameRdrName eqName+ge_RDR                  = nameRdrName geName+le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=")+lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<")+gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")+compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare")+ltTag_RDR               = nameRdrName  ordLTDataConName+eqTag_RDR               = nameRdrName  ordEQDataConName+gtTag_RDR               = nameRdrName  ordGTDataConName++eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR+    :: RdrName+eqClass_RDR             = nameRdrName eqClassName+numClass_RDR            = nameRdrName numClassName+ordClass_RDR            = nameRdrName ordClassName+enumClass_RDR           = nameRdrName enumClassName+monadClass_RDR          = nameRdrName monadClassName++map_RDR, append_RDR :: RdrName+map_RDR                 = nameRdrName mapName+append_RDR              = nameRdrName appendName++foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR+    :: RdrName+foldr_RDR               = nameRdrName foldrName+build_RDR               = nameRdrName buildName+returnM_RDR             = nameRdrName returnMName+bindM_RDR               = nameRdrName bindMName+failM_RDR               = nameRdrName failMName++left_RDR, right_RDR :: RdrName+left_RDR                = nameRdrName leftDataConName+right_RDR               = nameRdrName rightDataConName++fromEnum_RDR, toEnum_RDR :: RdrName+fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")+toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")++enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName+enumFrom_RDR            = nameRdrName enumFromName+enumFromTo_RDR          = nameRdrName enumFromToName+enumFromThen_RDR        = nameRdrName enumFromThenName+enumFromThenTo_RDR      = nameRdrName enumFromThenToName++ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName+ratioDataCon_RDR        = nameRdrName ratioDataConName+plusInteger_RDR         = nameRdrName plusIntegerName+timesInteger_RDR        = nameRdrName timesIntegerName++ioDataCon_RDR :: RdrName+ioDataCon_RDR           = nameRdrName ioDataConName++eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,+    unpackCStringUtf8_RDR :: RdrName+eqString_RDR            = nameRdrName eqStringName+unpackCString_RDR       = nameRdrName unpackCStringName+unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName+unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name++newStablePtr_RDR :: RdrName+newStablePtr_RDR        = nameRdrName newStablePtrName++bindIO_RDR, returnIO_RDR :: RdrName+bindIO_RDR              = nameRdrName bindIOName+returnIO_RDR            = nameRdrName returnIOName++fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName+fromInteger_RDR         = nameRdrName fromIntegerName+fromRational_RDR        = nameRdrName fromRationalName+minus_RDR               = nameRdrName minusName+times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")+plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")++toInteger_RDR, toRational_RDR, fromIntegral_RDR :: RdrName+toInteger_RDR           = nameRdrName toIntegerName+toRational_RDR          = nameRdrName toRationalName+fromIntegral_RDR        = nameRdrName fromIntegralName++stringTy_RDR, fromString_RDR :: RdrName+stringTy_RDR            = tcQual_RDR gHC_BASE (fsLit "String")+fromString_RDR          = nameRdrName fromStringName++fromList_RDR, fromListN_RDR, toList_RDR :: RdrName+fromList_RDR = nameRdrName fromListName+fromListN_RDR = nameRdrName fromListNName+toList_RDR = nameRdrName toListName++compose_RDR :: RdrName+compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")++not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,+    and_RDR, range_RDR, inRange_RDR, index_RDR,+    unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName+and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")+not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")+getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")+succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")+pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")+minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")+maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")+range_RDR               = varQual_RDR gHC_IX (fsLit "range")+inRange_RDR             = varQual_RDR gHC_IX (fsLit "inRange")+index_RDR               = varQual_RDR gHC_IX (fsLit "index")+unsafeIndex_RDR         = varQual_RDR gHC_IX (fsLit "unsafeIndex")+unsafeRangeSize_RDR     = varQual_RDR gHC_IX (fsLit "unsafeRangeSize")++readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,+    readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR, expectP_RDR :: RdrName+readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")+readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")+readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")+readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")+readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")+parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")+choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")+lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")+expectP_RDR             = varQual_RDR gHC_READ (fsLit "expectP")++readField_RDR, readFieldHash_RDR, readSymField_RDR :: RdrName+readField_RDR           = varQual_RDR gHC_READ (fsLit "readField")+readFieldHash_RDR       = varQual_RDR gHC_READ (fsLit "readFieldHash")+readSymField_RDR        = varQual_RDR gHC_READ (fsLit "readSymField")++punc_RDR, ident_RDR, symbol_RDR :: RdrName+punc_RDR                = dataQual_RDR lEX (fsLit "Punc")+ident_RDR               = dataQual_RDR lEX (fsLit "Ident")+symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")++step_RDR, alt_RDR, reset_RDR, prec_RDR, pfail_RDR :: RdrName+step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")+alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")+reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")+prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")+pfail_RDR               = varQual_RDR  rEAD_PREC (fsLit "pfail")++showsPrec_RDR, shows_RDR, showString_RDR,+    showSpace_RDR, showCommaSpace_RDR, showParen_RDR :: RdrName+showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")+shows_RDR               = varQual_RDR gHC_SHOW (fsLit "shows")+showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")+showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")+showCommaSpace_RDR      = varQual_RDR gHC_SHOW (fsLit "showCommaSpace")+showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")++error_RDR :: RdrName+error_RDR = varQual_RDR gHC_ERR (fsLit "error")++-- Generics (constructors and functions)+u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,+  k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,+  prodDataCon_RDR, comp1DataCon_RDR,+  unPar1_RDR, unRec1_RDR, unK1_RDR, unComp1_RDR,+  from_RDR, from1_RDR, to_RDR, to1_RDR,+  datatypeName_RDR, moduleName_RDR, packageName_RDR, isNewtypeName_RDR,+  conName_RDR, conFixity_RDR, conIsRecord_RDR, selName_RDR,+  prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,+  rightAssocDataCon_RDR, notAssocDataCon_RDR,+  uAddrDataCon_RDR, uCharDataCon_RDR, uDoubleDataCon_RDR,+  uFloatDataCon_RDR, uIntDataCon_RDR, uWordDataCon_RDR,+  uAddrHash_RDR, uCharHash_RDR, uDoubleHash_RDR,+  uFloatHash_RDR, uIntHash_RDR, uWordHash_RDR :: RdrName++u1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "U1")+par1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Par1")+rec1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Rec1")+k1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "K1")+m1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "M1")++l1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "L1")+r1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "R1")++prodDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")+comp1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Comp1")++unPar1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unPar1")+unRec1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unRec1")+unK1_RDR    = varQual_RDR gHC_GENERICS (fsLit "unK1")+unComp1_RDR = varQual_RDR gHC_GENERICS (fsLit "unComp1")++from_RDR  = varQual_RDR gHC_GENERICS (fsLit "from")+from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")+to_RDR    = varQual_RDR gHC_GENERICS (fsLit "to")+to1_RDR   = varQual_RDR gHC_GENERICS (fsLit "to1")++datatypeName_RDR  = varQual_RDR gHC_GENERICS (fsLit "datatypeName")+moduleName_RDR    = varQual_RDR gHC_GENERICS (fsLit "moduleName")+packageName_RDR   = varQual_RDR gHC_GENERICS (fsLit "packageName")+isNewtypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "isNewtype")+selName_RDR       = varQual_RDR gHC_GENERICS (fsLit "selName")+conName_RDR       = varQual_RDR gHC_GENERICS (fsLit "conName")+conFixity_RDR     = varQual_RDR gHC_GENERICS (fsLit "conFixity")+conIsRecord_RDR   = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")++prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")+infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")+leftAssocDataCon_RDR  = nameRdrName leftAssociativeDataConName+rightAssocDataCon_RDR = nameRdrName rightAssociativeDataConName+notAssocDataCon_RDR   = nameRdrName notAssociativeDataConName++uAddrDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "UAddr")+uCharDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "UChar")+uDoubleDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "UDouble")+uFloatDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "UFloat")+uIntDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "UInt")+uWordDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "UWord")++uAddrHash_RDR   = varQual_RDR gHC_GENERICS (fsLit "uAddr#")+uCharHash_RDR   = varQual_RDR gHC_GENERICS (fsLit "uChar#")+uDoubleHash_RDR = varQual_RDR gHC_GENERICS (fsLit "uDouble#")+uFloatHash_RDR  = varQual_RDR gHC_GENERICS (fsLit "uFloat#")+uIntHash_RDR    = varQual_RDR gHC_GENERICS (fsLit "uInt#")+uWordHash_RDR   = varQual_RDR gHC_GENERICS (fsLit "uWord#")++fmap_RDR, replace_RDR, pure_RDR, ap_RDR, liftA2_RDR, foldable_foldr_RDR,+    foldMap_RDR, null_RDR, all_RDR, traverse_RDR, mempty_RDR,+    mappend_RDR :: RdrName+fmap_RDR                = nameRdrName fmapName+replace_RDR             = varQual_RDR gHC_BASE (fsLit "<$")+pure_RDR                = nameRdrName pureAName+ap_RDR                  = nameRdrName apAName+liftA2_RDR              = varQual_RDR gHC_BASE (fsLit "liftA2")+foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")+foldMap_RDR             = varQual_RDR dATA_FOLDABLE       (fsLit "foldMap")+null_RDR                = varQual_RDR dATA_FOLDABLE       (fsLit "null")+all_RDR                 = varQual_RDR dATA_FOLDABLE       (fsLit "all")+traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")+mempty_RDR              = nameRdrName memptyName+mappend_RDR             = nameRdrName mappendName++----------------------+varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR+    :: Module -> FastString -> RdrName+varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)+tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)+clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)+dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)++{-+************************************************************************+*                                                                      *+\subsection{Known-key names}+*                                                                      *+************************************************************************++Many of these Names are not really "built in", but some parts of the+compiler (notably the deriving mechanism) need to mention their names,+and it's convenient to write them all down in one place.+-}++wildCardName :: Name+wildCardName = mkSystemVarName wildCardKey (fsLit "wild")++runMainIOName, runRWName :: Name+runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey+runRWName     = varQual gHC_MAGIC       (fsLit "runRW#")    runRWKey++orderingTyConName, ordLTDataConName, ordEQDataConName, ordGTDataConName :: Name+orderingTyConName = tcQual  gHC_TYPES (fsLit "Ordering") orderingTyConKey+ordLTDataConName     = dcQual gHC_TYPES (fsLit "LT") ordLTDataConKey+ordEQDataConName     = dcQual gHC_TYPES (fsLit "EQ") ordEQDataConKey+ordGTDataConName     = dcQual gHC_TYPES (fsLit "GT") ordGTDataConKey++specTyConName :: Name+specTyConName     = tcQual gHC_TYPES (fsLit "SPEC") specTyConKey++eitherTyConName, leftDataConName, rightDataConName :: Name+eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey+leftDataConName   = dcQual dATA_EITHER (fsLit "Left")   leftDataConKey+rightDataConName  = dcQual dATA_EITHER (fsLit "Right")  rightDataConKey++-- Generics (types)+v1TyConName, u1TyConName, par1TyConName, rec1TyConName,+  k1TyConName, m1TyConName, sumTyConName, prodTyConName,+  compTyConName, rTyConName, dTyConName,+  cTyConName, sTyConName, rec0TyConName,+  d1TyConName, c1TyConName, s1TyConName, noSelTyConName,+  repTyConName, rep1TyConName, uRecTyConName,+  uAddrTyConName, uCharTyConName, uDoubleTyConName,+  uFloatTyConName, uIntTyConName, uWordTyConName,+  prefixIDataConName, infixIDataConName, leftAssociativeDataConName,+  rightAssociativeDataConName, notAssociativeDataConName,+  sourceUnpackDataConName, sourceNoUnpackDataConName,+  noSourceUnpackednessDataConName, sourceLazyDataConName,+  sourceStrictDataConName, noSourceStrictnessDataConName,+  decidedLazyDataConName, decidedStrictDataConName, decidedUnpackDataConName,+  metaDataDataConName, metaConsDataConName, metaSelDataConName :: Name++v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey+u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey+par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey+rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey+k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey+m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey++sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey+prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey+compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey++rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey+dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey+cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey+sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey++rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey+d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey+c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey+s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey+noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey++repTyConName  = tcQual gHC_GENERICS (fsLit "Rep")  repTyConKey+rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey++uRecTyConName      = tcQual gHC_GENERICS (fsLit "URec") uRecTyConKey+uAddrTyConName     = tcQual gHC_GENERICS (fsLit "UAddr") uAddrTyConKey+uCharTyConName     = tcQual gHC_GENERICS (fsLit "UChar") uCharTyConKey+uDoubleTyConName   = tcQual gHC_GENERICS (fsLit "UDouble") uDoubleTyConKey+uFloatTyConName    = tcQual gHC_GENERICS (fsLit "UFloat") uFloatTyConKey+uIntTyConName      = tcQual gHC_GENERICS (fsLit "UInt") uIntTyConKey+uWordTyConName     = tcQual gHC_GENERICS (fsLit "UWord") uWordTyConKey++prefixIDataConName = dcQual gHC_GENERICS (fsLit "PrefixI")  prefixIDataConKey+infixIDataConName  = dcQual gHC_GENERICS (fsLit "InfixI")   infixIDataConKey+leftAssociativeDataConName  = dcQual gHC_GENERICS (fsLit "LeftAssociative")   leftAssociativeDataConKey+rightAssociativeDataConName = dcQual gHC_GENERICS (fsLit "RightAssociative")  rightAssociativeDataConKey+notAssociativeDataConName   = dcQual gHC_GENERICS (fsLit "NotAssociative")    notAssociativeDataConKey++sourceUnpackDataConName         = dcQual gHC_GENERICS (fsLit "SourceUnpack")         sourceUnpackDataConKey+sourceNoUnpackDataConName       = dcQual gHC_GENERICS (fsLit "SourceNoUnpack")       sourceNoUnpackDataConKey+noSourceUnpackednessDataConName = dcQual gHC_GENERICS (fsLit "NoSourceUnpackedness") noSourceUnpackednessDataConKey+sourceLazyDataConName           = dcQual gHC_GENERICS (fsLit "SourceLazy")           sourceLazyDataConKey+sourceStrictDataConName         = dcQual gHC_GENERICS (fsLit "SourceStrict")         sourceStrictDataConKey+noSourceStrictnessDataConName   = dcQual gHC_GENERICS (fsLit "NoSourceStrictness")   noSourceStrictnessDataConKey+decidedLazyDataConName          = dcQual gHC_GENERICS (fsLit "DecidedLazy")          decidedLazyDataConKey+decidedStrictDataConName        = dcQual gHC_GENERICS (fsLit "DecidedStrict")        decidedStrictDataConKey+decidedUnpackDataConName        = dcQual gHC_GENERICS (fsLit "DecidedUnpack")        decidedUnpackDataConKey++metaDataDataConName  = dcQual gHC_GENERICS (fsLit "MetaData")  metaDataDataConKey+metaConsDataConName  = dcQual gHC_GENERICS (fsLit "MetaCons")  metaConsDataConKey+metaSelDataConName   = dcQual gHC_GENERICS (fsLit "MetaSel")   metaSelDataConKey++-- Primitive Int+divIntName, modIntName :: Name+divIntName = varQual gHC_CLASSES (fsLit "divInt#") divIntIdKey+modIntName = varQual gHC_CLASSES (fsLit "modInt#") modIntIdKey++-- Base strings Strings+unpackCStringName, unpackCStringFoldrName,+    unpackCStringUtf8Name, eqStringName :: Name+unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey+unpackCStringFoldrName  = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey+unpackCStringUtf8Name   = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey+eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey++-- The 'inline' function+inlineIdName :: Name+inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey++-- Base classes (Eq, Ord, Functor)+fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name+eqClassName       = clsQual gHC_CLASSES (fsLit "Eq")      eqClassKey+eqName            = varQual gHC_CLASSES (fsLit "==")      eqClassOpKey+ordClassName      = clsQual gHC_CLASSES (fsLit "Ord")     ordClassKey+geName            = varQual gHC_CLASSES (fsLit ">=")      geClassOpKey+functorClassName  = clsQual gHC_BASE    (fsLit "Functor") functorClassKey+fmapName          = varQual gHC_BASE    (fsLit "fmap")    fmapClassOpKey++-- Class Monad+monadClassName, thenMName, bindMName, returnMName :: Name+monadClassName     = clsQual gHC_BASE (fsLit "Monad")  monadClassKey+thenMName          = varQual gHC_BASE (fsLit ">>")     thenMClassOpKey+bindMName          = varQual gHC_BASE (fsLit ">>=")    bindMClassOpKey+returnMName        = varQual gHC_BASE (fsLit "return") returnMClassOpKey++-- Class MonadFail+monadFailClassName, failMName :: Name+monadFailClassName = clsQual mONAD_FAIL (fsLit "MonadFail") monadFailClassKey+failMName          = varQual mONAD_FAIL (fsLit "fail")      failMClassOpKey++-- Class Applicative+applicativeClassName, pureAName, apAName, thenAName :: Name+applicativeClassName = clsQual gHC_BASE (fsLit "Applicative") applicativeClassKey+apAName              = varQual gHC_BASE (fsLit "<*>")         apAClassOpKey+pureAName            = varQual gHC_BASE (fsLit "pure")        pureAClassOpKey+thenAName            = varQual gHC_BASE (fsLit "*>")          thenAClassOpKey++-- Classes (Foldable, Traversable)+foldableClassName, traversableClassName :: Name+foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey+traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey++-- Classes (Semigroup, Monoid)+semigroupClassName, sappendName :: Name+semigroupClassName = clsQual gHC_BASE       (fsLit "Semigroup") semigroupClassKey+sappendName        = varQual gHC_BASE       (fsLit "<>")        sappendClassOpKey+monoidClassName, memptyName, mappendName, mconcatName :: Name+monoidClassName    = clsQual gHC_BASE       (fsLit "Monoid")    monoidClassKey+memptyName         = varQual gHC_BASE       (fsLit "mempty")    memptyClassOpKey+mappendName        = varQual gHC_BASE       (fsLit "mappend")   mappendClassOpKey+mconcatName        = varQual gHC_BASE       (fsLit "mconcat")   mconcatClassOpKey++++-- AMP additions++joinMName, alternativeClassName :: Name+joinMName            = varQual gHC_BASE (fsLit "join")        joinMIdKey+alternativeClassName = clsQual mONAD (fsLit "Alternative") alternativeClassKey++--+joinMIdKey, apAClassOpKey, pureAClassOpKey, thenAClassOpKey,+    alternativeClassKey :: Unique+joinMIdKey          = mkPreludeMiscIdUnique 750+apAClassOpKey       = mkPreludeMiscIdUnique 751 -- <*>+pureAClassOpKey     = mkPreludeMiscIdUnique 752+thenAClassOpKey     = mkPreludeMiscIdUnique 753+alternativeClassKey = mkPreludeMiscIdUnique 754+++-- Functions for GHC extensions+groupWithName :: Name+groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey++-- Random PrelBase functions+fromStringName, otherwiseIdName, foldrName, buildName, augmentName,+    mapName, appendName, assertName,+    breakpointName, breakpointCondName,+    opaqueTyConName, dollarName :: Name+dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey+otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey+foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey+buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey+augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey+mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey+appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey+assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey+breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey+breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey+opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")     opaqueTyConKey+fromStringName = varQual dATA_STRING (fsLit "fromString") fromStringClassOpKey++-- PrelTup+fstName, sndName :: Name+fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey+sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey++-- Module GHC.Num+numClassName, fromIntegerName, minusName, negateName :: Name+numClassName      = clsQual gHC_NUM (fsLit "Num")         numClassKey+fromIntegerName   = varQual gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey+minusName         = varQual gHC_NUM (fsLit "-")           minusClassOpKey+negateName        = varQual gHC_NUM (fsLit "negate")      negateClassOpKey++integerTyConName, mkIntegerName, integerSDataConName,+    integerToWord64Name, integerToInt64Name,+    word64ToIntegerName, int64ToIntegerName,+    plusIntegerName, timesIntegerName, smallIntegerName,+    wordToIntegerName,+    integerToWordName, integerToIntName, minusIntegerName,+    negateIntegerName, eqIntegerPrimName, neqIntegerPrimName,+    absIntegerName, signumIntegerName,+    leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,+    compareIntegerName, quotRemIntegerName, divModIntegerName,+    quotIntegerName, remIntegerName, divIntegerName, modIntegerName,+    floatFromIntegerName, doubleFromIntegerName,+    encodeFloatIntegerName, encodeDoubleIntegerName,+    decodeDoubleIntegerName,+    gcdIntegerName, lcmIntegerName,+    andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,+    shiftLIntegerName, shiftRIntegerName, bitIntegerName :: Name+integerTyConName      = tcQual gHC_INTEGER_TYPE (fsLit "Integer")           integerTyConKey+integerSDataConName   = dcQual gHC_INTEGER_TYPE (fsLit "S#")                integerSDataConKey+mkIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "mkInteger")         mkIntegerIdKey+integerToWord64Name   = varQual gHC_INTEGER_TYPE (fsLit "integerToWord64")   integerToWord64IdKey+integerToInt64Name    = varQual gHC_INTEGER_TYPE (fsLit "integerToInt64")    integerToInt64IdKey+word64ToIntegerName   = varQual gHC_INTEGER_TYPE (fsLit "word64ToInteger")   word64ToIntegerIdKey+int64ToIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "int64ToInteger")    int64ToIntegerIdKey+plusIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "plusInteger")       plusIntegerIdKey+timesIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "timesInteger")      timesIntegerIdKey+smallIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "smallInteger")      smallIntegerIdKey+wordToIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "wordToInteger")     wordToIntegerIdKey+integerToWordName     = varQual gHC_INTEGER_TYPE (fsLit "integerToWord")     integerToWordIdKey+integerToIntName      = varQual gHC_INTEGER_TYPE (fsLit "integerToInt")      integerToIntIdKey+minusIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "minusInteger")      minusIntegerIdKey+negateIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "negateInteger")     negateIntegerIdKey+eqIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "eqInteger#")        eqIntegerPrimIdKey+neqIntegerPrimName    = varQual gHC_INTEGER_TYPE (fsLit "neqInteger#")       neqIntegerPrimIdKey+absIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "absInteger")        absIntegerIdKey+signumIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "signumInteger")     signumIntegerIdKey+leIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "leInteger#")        leIntegerPrimIdKey+gtIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "gtInteger#")        gtIntegerPrimIdKey+ltIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "ltInteger#")        ltIntegerPrimIdKey+geIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "geInteger#")        geIntegerPrimIdKey+compareIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "compareInteger")    compareIntegerIdKey+quotRemIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "quotRemInteger")    quotRemIntegerIdKey+divModIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "divModInteger")     divModIntegerIdKey+quotIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "quotInteger")       quotIntegerIdKey+remIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "remInteger")        remIntegerIdKey+divIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "divInteger")        divIntegerIdKey+modIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "modInteger")        modIntegerIdKey+floatFromIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "floatFromInteger")      floatFromIntegerIdKey+doubleFromIntegerName = varQual gHC_INTEGER_TYPE (fsLit "doubleFromInteger")     doubleFromIntegerIdKey+encodeFloatIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "encodeFloatInteger")  encodeFloatIntegerIdKey+encodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "encodeDoubleInteger") encodeDoubleIntegerIdKey+decodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "decodeDoubleInteger") decodeDoubleIntegerIdKey+gcdIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "gcdInteger")        gcdIntegerIdKey+lcmIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "lcmInteger")        lcmIntegerIdKey+andIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "andInteger")        andIntegerIdKey+orIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "orInteger")         orIntegerIdKey+xorIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "xorInteger")        xorIntegerIdKey+complementIntegerName = varQual gHC_INTEGER_TYPE (fsLit "complementInteger") complementIntegerIdKey+shiftLIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftLInteger")     shiftLIntegerIdKey+shiftRIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftRInteger")     shiftRIntegerIdKey+bitIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "bitInteger")        bitIntegerIdKey++-- GHC.Natural types+naturalTyConName, naturalSDataConName :: Name+naturalTyConName     = tcQual gHC_NATURAL (fsLit "Natural") naturalTyConKey+naturalSDataConName  = dcQual gHC_NATURAL (fsLit "NatS#")   naturalSDataConKey++naturalFromIntegerName :: Name+naturalFromIntegerName = varQual gHC_NATURAL (fsLit "naturalFromInteger") naturalFromIntegerIdKey++naturalToIntegerName, plusNaturalName, minusNaturalName, timesNaturalName,+   mkNaturalName, wordToNaturalName :: Name+naturalToIntegerName  = varQual gHC_NATURAL (fsLit "naturalToInteger")  naturalToIntegerIdKey+plusNaturalName       = varQual gHC_NATURAL (fsLit "plusNatural")       plusNaturalIdKey+minusNaturalName      = varQual gHC_NATURAL (fsLit "minusNatural")      minusNaturalIdKey+timesNaturalName      = varQual gHC_NATURAL (fsLit "timesNatural")      timesNaturalIdKey+mkNaturalName         = varQual gHC_NATURAL (fsLit "mkNatural")         mkNaturalIdKey+wordToNaturalName     = varQual gHC_NATURAL (fsLit "wordToNatural#")    wordToNaturalIdKey++-- GHC.Real types and classes+rationalTyConName, ratioTyConName, ratioDataConName, realClassName,+    integralClassName, realFracClassName, fractionalClassName,+    fromRationalName, toIntegerName, toRationalName, fromIntegralName,+    realToFracName :: Name+rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational")     rationalTyConKey+ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio")        ratioTyConKey+ratioDataConName    = dcQual  gHC_REAL (fsLit ":%")           ratioDataConKey+realClassName       = clsQual gHC_REAL (fsLit "Real")         realClassKey+integralClassName   = clsQual gHC_REAL (fsLit "Integral")     integralClassKey+realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac")     realFracClassKey+fractionalClassName = clsQual gHC_REAL (fsLit "Fractional")   fractionalClassKey+fromRationalName    = varQual gHC_REAL (fsLit "fromRational") fromRationalClassOpKey+toIntegerName       = varQual gHC_REAL (fsLit "toInteger")    toIntegerClassOpKey+toRationalName      = varQual gHC_REAL (fsLit "toRational")   toRationalClassOpKey+fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral")fromIntegralIdKey+realToFracName      = varQual  gHC_REAL (fsLit "realToFrac")  realToFracIdKey++-- PrelFloat classes+floatingClassName, realFloatClassName :: Name+floatingClassName  = clsQual gHC_FLOAT (fsLit "Floating")  floatingClassKey+realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey++-- other GHC.Float functions+rationalToFloatName, rationalToDoubleName :: Name+rationalToFloatName  = varQual gHC_FLOAT (fsLit "rationalToFloat") rationalToFloatIdKey+rationalToDoubleName = varQual gHC_FLOAT (fsLit "rationalToDouble") rationalToDoubleIdKey++-- Class Ix+ixClassName :: Name+ixClassName = clsQual gHC_IX (fsLit "Ix") ixClassKey++-- Typeable representation types+trModuleTyConName+  , trModuleDataConName+  , trNameTyConName+  , trNameSDataConName+  , trNameDDataConName+  , trTyConTyConName+  , trTyConDataConName+  :: Name+trModuleTyConName     = tcQual gHC_TYPES          (fsLit "Module")         trModuleTyConKey+trModuleDataConName   = dcQual gHC_TYPES          (fsLit "Module")         trModuleDataConKey+trNameTyConName       = tcQual gHC_TYPES          (fsLit "TrName")         trNameTyConKey+trNameSDataConName    = dcQual gHC_TYPES          (fsLit "TrNameS")        trNameSDataConKey+trNameDDataConName    = dcQual gHC_TYPES          (fsLit "TrNameD")        trNameDDataConKey+trTyConTyConName      = tcQual gHC_TYPES          (fsLit "TyCon")          trTyConTyConKey+trTyConDataConName    = dcQual gHC_TYPES          (fsLit "TyCon")          trTyConDataConKey++kindRepTyConName+  , kindRepTyConAppDataConName+  , kindRepVarDataConName+  , kindRepAppDataConName+  , kindRepFunDataConName+  , kindRepTYPEDataConName+  , kindRepTypeLitSDataConName+  , kindRepTypeLitDDataConName+  :: Name+kindRepTyConName      = tcQual gHC_TYPES          (fsLit "KindRep")        kindRepTyConKey+kindRepTyConAppDataConName = dcQual gHC_TYPES     (fsLit "KindRepTyConApp") kindRepTyConAppDataConKey+kindRepVarDataConName = dcQual gHC_TYPES          (fsLit "KindRepVar")     kindRepVarDataConKey+kindRepAppDataConName = dcQual gHC_TYPES          (fsLit "KindRepApp")     kindRepAppDataConKey+kindRepFunDataConName = dcQual gHC_TYPES          (fsLit "KindRepFun")     kindRepFunDataConKey+kindRepTYPEDataConName = dcQual gHC_TYPES         (fsLit "KindRepTYPE")    kindRepTYPEDataConKey+kindRepTypeLitSDataConName = dcQual gHC_TYPES     (fsLit "KindRepTypeLitS") kindRepTypeLitSDataConKey+kindRepTypeLitDDataConName = dcQual gHC_TYPES     (fsLit "KindRepTypeLitD") kindRepTypeLitDDataConKey++typeLitSortTyConName+  , typeLitSymbolDataConName+  , typeLitNatDataConName+  :: Name+typeLitSortTyConName     = tcQual gHC_TYPES       (fsLit "TypeLitSort")    typeLitSortTyConKey+typeLitSymbolDataConName = dcQual gHC_TYPES       (fsLit "TypeLitSymbol")  typeLitSymbolDataConKey+typeLitNatDataConName    = dcQual gHC_TYPES       (fsLit "TypeLitNat")     typeLitNatDataConKey++-- Class Typeable, and functions for constructing `Typeable` dictionaries+typeableClassName+  , typeRepTyConName+  , someTypeRepTyConName+  , someTypeRepDataConName+  , mkTrTypeName+  , mkTrConName+  , mkTrAppName+  , mkTrFunName+  , typeRepIdName+  , typeNatTypeRepName+  , typeSymbolTypeRepName+  , trGhcPrimModuleName+  :: Name+typeableClassName     = clsQual tYPEABLE_INTERNAL (fsLit "Typeable")       typeableClassKey+typeRepTyConName      = tcQual  tYPEABLE_INTERNAL (fsLit "TypeRep")        typeRepTyConKey+someTypeRepTyConName   = tcQual tYPEABLE_INTERNAL (fsLit "SomeTypeRep")    someTypeRepTyConKey+someTypeRepDataConName = dcQual tYPEABLE_INTERNAL (fsLit "SomeTypeRep")    someTypeRepDataConKey+typeRepIdName         = varQual tYPEABLE_INTERNAL (fsLit "typeRep#")       typeRepIdKey+mkTrTypeName          = varQual tYPEABLE_INTERNAL (fsLit "mkTrType")       mkTrTypeKey+mkTrConName           = varQual tYPEABLE_INTERNAL (fsLit "mkTrCon")        mkTrConKey+mkTrAppName           = varQual tYPEABLE_INTERNAL (fsLit "mkTrApp")        mkTrAppKey+mkTrFunName           = varQual tYPEABLE_INTERNAL (fsLit "mkTrFun")        mkTrFunKey+typeNatTypeRepName    = varQual tYPEABLE_INTERNAL (fsLit "typeNatTypeRep") typeNatTypeRepKey+typeSymbolTypeRepName = varQual tYPEABLE_INTERNAL (fsLit "typeSymbolTypeRep") typeSymbolTypeRepKey+-- this is the Typeable 'Module' for GHC.Prim (which has no code, so we place in GHC.Types)+-- See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.+trGhcPrimModuleName   = varQual gHC_TYPES         (fsLit "tr$ModuleGHCPrim")  trGhcPrimModuleKey++-- Typeable KindReps for some common cases+starKindRepName, starArrStarKindRepName, starArrStarArrStarKindRepName :: Name+starKindRepName        = varQual gHC_TYPES         (fsLit "krep$*")         starKindRepKey+starArrStarKindRepName = varQual gHC_TYPES         (fsLit "krep$*Arr*")     starArrStarKindRepKey+starArrStarArrStarKindRepName = varQual gHC_TYPES  (fsLit "krep$*->*->*")   starArrStarArrStarKindRepKey++-- Custom type errors+errorMessageTypeErrorFamName+  , typeErrorTextDataConName+  , typeErrorAppendDataConName+  , typeErrorVAppendDataConName+  , typeErrorShowTypeDataConName+  :: Name++errorMessageTypeErrorFamName =+  tcQual gHC_TYPELITS (fsLit "TypeError") errorMessageTypeErrorFamKey++typeErrorTextDataConName =+  dcQual gHC_TYPELITS (fsLit "Text") typeErrorTextDataConKey++typeErrorAppendDataConName =+  dcQual gHC_TYPELITS (fsLit ":<>:") typeErrorAppendDataConKey++typeErrorVAppendDataConName =+  dcQual gHC_TYPELITS (fsLit ":$$:") typeErrorVAppendDataConKey++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+toDynName = varQual dYNAMIC (fsLit "toDyn") toDynIdKey++-- Class Data+dataClassName :: Name+dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey++-- Error module+assertErrorName    :: Name+assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey++-- Debug.Trace+traceName          :: Name+traceName         = varQual dEBUG_TRACE (fsLit "trace") traceKey++-- Enum module (Enum, Bounded)+enumClassName, enumFromName, enumFromToName, enumFromThenName,+    enumFromThenToName, boundedClassName :: Name+enumClassName      = clsQual gHC_ENUM (fsLit "Enum")           enumClassKey+enumFromName       = varQual gHC_ENUM (fsLit "enumFrom")       enumFromClassOpKey+enumFromToName     = varQual gHC_ENUM (fsLit "enumFromTo")     enumFromToClassOpKey+enumFromThenName   = varQual gHC_ENUM (fsLit "enumFromThen")   enumFromThenClassOpKey+enumFromThenToName = varQual gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey+boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded")        boundedClassKey++-- List functions+concatName, filterName, zipName :: Name+concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey+filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey+zipName           = varQual gHC_LIST (fsLit "zip")    zipIdKey++-- Overloaded lists+isListClassName, fromListName, fromListNName, toListName :: Name+isListClassName = clsQual gHC_EXTS (fsLit "IsList")    isListClassKey+fromListName    = varQual gHC_EXTS (fsLit "fromList")  fromListClassOpKey+fromListNName   = varQual gHC_EXTS (fsLit "fromListN") fromListNClassOpKey+toListName      = varQual gHC_EXTS (fsLit "toList")    toListClassOpKey++-- Class Show+showClassName :: Name+showClassName   = clsQual gHC_SHOW (fsLit "Show")      showClassKey++-- Class Read+readClassName :: Name+readClassName   = clsQual gHC_READ (fsLit "Read")      readClassKey++-- Classes Generic and Generic1, Datatype, Constructor and Selector+genClassName, gen1ClassName, datatypeClassName, constructorClassName,+  selectorClassName :: Name+genClassName  = clsQual gHC_GENERICS (fsLit "Generic")  genClassKey+gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey++datatypeClassName    = clsQual gHC_GENERICS (fsLit "Datatype")    datatypeClassKey+constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey+selectorClassName    = clsQual gHC_GENERICS (fsLit "Selector")    selectorClassKey++genericClassNames :: [Name]+genericClassNames = [genClassName, gen1ClassName]++-- GHCi things+ghciIoClassName, ghciStepIoMName :: Name+ghciIoClassName = clsQual gHC_GHCI (fsLit "GHCiSandboxIO") ghciIoClassKey+ghciStepIoMName = varQual gHC_GHCI (fsLit "ghciStepIO") ghciStepIoMClassOpKey++-- IO things+ioTyConName, ioDataConName,+  thenIOName, bindIOName, returnIOName, failIOName :: Name+ioTyConName       = tcQual  gHC_TYPES (fsLit "IO")       ioTyConKey+ioDataConName     = dcQual  gHC_TYPES (fsLit "IO")       ioDataConKey+thenIOName        = varQual gHC_BASE  (fsLit "thenIO")   thenIOIdKey+bindIOName        = varQual gHC_BASE  (fsLit "bindIO")   bindIOIdKey+returnIOName      = varQual gHC_BASE  (fsLit "returnIO") returnIOIdKey+failIOName        = varQual gHC_IO    (fsLit "failIO")   failIOIdKey++-- IO things+printName :: Name+printName         = varQual sYSTEM_IO (fsLit "print") printIdKey++-- Int, Word, and Addr things+int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name+int8TyConName     = tcQual gHC_INT  (fsLit "Int8")  int8TyConKey+int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey+int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey+int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey++-- Word module+word16TyConName, word32TyConName, word64TyConName :: Name+word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey+word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey+word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey++-- PrelPtr module+ptrTyConName, funPtrTyConName :: Name+ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr")    ptrTyConKey+funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey++-- Foreign objects and weak pointers+stablePtrTyConName, newStablePtrName :: Name+stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr")    stablePtrTyConKey+newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey++-- Recursive-do notation+monadFixClassName, mfixName :: Name+monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey+mfixName           = varQual mONAD_FIX (fsLit "mfix")     mfixIdKey++-- Arrow notation+arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name+arrAName           = varQual aRROW (fsLit "arr")       arrAIdKey+composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey+firstAName         = varQual aRROW (fsLit "first")     firstAIdKey+appAName           = varQual aRROW (fsLit "app")       appAIdKey+choiceAName        = varQual aRROW (fsLit "|||")       choiceAIdKey+loopAName          = varQual aRROW (fsLit "loop")      loopAIdKey++-- Monad comprehensions+guardMName, liftMName, mzipName :: Name+guardMName         = varQual mONAD (fsLit "guard")    guardMIdKey+liftMName          = varQual mONAD (fsLit "liftM")    liftMIdKey+mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey+++-- Annotation type checking+toAnnotationWrapperName :: Name+toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey++-- Other classes, needed for type defaulting+monadPlusClassName, randomClassName, randomGenClassName,+    isStringClassName :: Name+monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")      monadPlusClassKey+randomClassName     = clsQual rANDOM (fsLit "Random")        randomClassKey+randomGenClassName  = clsQual rANDOM (fsLit "RandomGen")     randomGenClassKey+isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey++-- Type-level naturals+knownNatClassName :: Name+knownNatClassName     = clsQual gHC_TYPENATS (fsLit "KnownNat") knownNatClassNameKey+knownSymbolClassName :: Name+knownSymbolClassName  = clsQual gHC_TYPELITS (fsLit "KnownSymbol") knownSymbolClassNameKey++-- Overloaded labels+isLabelClassName :: Name+isLabelClassName+ = clsQual gHC_OVER_LABELS (fsLit "IsLabel") isLabelClassNameKey++-- Implicit Parameters+ipClassName :: Name+ipClassName+  = clsQual gHC_CLASSES (fsLit "IP") ipClassKey++-- Overloaded record fields+hasFieldClassName :: Name+hasFieldClassName+ = clsQual gHC_RECORDS (fsLit "HasField") hasFieldClassNameKey++-- Source Locations+callStackTyConName, emptyCallStackName, pushCallStackName,+  srcLocDataConName :: Name+callStackTyConName+  = tcQual gHC_STACK_TYPES  (fsLit "CallStack") callStackTyConKey+emptyCallStackName+  = varQual gHC_STACK_TYPES (fsLit "emptyCallStack") emptyCallStackKey+pushCallStackName+  = varQual gHC_STACK_TYPES (fsLit "pushCallStack") pushCallStackKey+srcLocDataConName+  = dcQual gHC_STACK_TYPES  (fsLit "SrcLoc")    srcLocDataConKey++-- plugins+pLUGINS :: Module+pLUGINS = mkThisGhcModule (fsLit "GHC.Driver.Plugins")+pluginTyConName :: Name+pluginTyConName = tcQual pLUGINS (fsLit "Plugin") pluginTyConKey+frontendPluginTyConName :: Name+frontendPluginTyConName = tcQual pLUGINS (fsLit "FrontendPlugin") frontendPluginTyConKey++-- Static pointers+makeStaticName :: Name+makeStaticName =+    varQual gHC_STATICPTR_INTERNAL (fsLit "makeStatic") makeStaticKey++staticPtrInfoTyConName :: Name+staticPtrInfoTyConName =+    tcQual gHC_STATICPTR (fsLit "StaticPtrInfo") staticPtrInfoTyConKey++staticPtrInfoDataConName :: Name+staticPtrInfoDataConName =+    dcQual gHC_STATICPTR (fsLit "StaticPtrInfo") staticPtrInfoDataConKey++staticPtrTyConName :: Name+staticPtrTyConName =+    tcQual gHC_STATICPTR (fsLit "StaticPtr") staticPtrTyConKey++staticPtrDataConName :: Name+staticPtrDataConName =+    dcQual gHC_STATICPTR (fsLit "StaticPtr") staticPtrDataConKey++fromStaticPtrName :: Name+fromStaticPtrName =+    varQual gHC_STATICPTR (fsLit "fromStaticPtr") fromStaticPtrClassOpKey++fingerprintDataConName :: Name+fingerprintDataConName =+    dcQual gHC_FINGERPRINT_TYPE (fsLit "Fingerprint") fingerprintDataConKey++{-+************************************************************************+*                                                                      *+\subsection{Local helpers}+*                                                                      *+************************************************************************++All these are original names; hence mkOrig+-}++varQual, tcQual, clsQual, dcQual :: Module -> FastString -> Unique -> Name+varQual  = mk_known_key_name varName+tcQual   = mk_known_key_name tcName+clsQual  = mk_known_key_name clsName+dcQual   = mk_known_key_name dataName++mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name+mk_known_key_name space modu str unique+  = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan+++{-+************************************************************************+*                                                                      *+\subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}+*                                                                      *+************************************************************************+--MetaHaskell extension hand allocate keys here+-}++boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,+    fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,+    functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,+    realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique+boundedClassKey         = mkPreludeClassUnique 1+enumClassKey            = mkPreludeClassUnique 2+eqClassKey              = mkPreludeClassUnique 3+floatingClassKey        = mkPreludeClassUnique 5+fractionalClassKey      = mkPreludeClassUnique 6+integralClassKey        = mkPreludeClassUnique 7+monadClassKey           = mkPreludeClassUnique 8+dataClassKey            = mkPreludeClassUnique 9+functorClassKey         = mkPreludeClassUnique 10+numClassKey             = mkPreludeClassUnique 11+ordClassKey             = mkPreludeClassUnique 12+readClassKey            = mkPreludeClassUnique 13+realClassKey            = mkPreludeClassUnique 14+realFloatClassKey       = mkPreludeClassUnique 15+realFracClassKey        = mkPreludeClassUnique 16+showClassKey            = mkPreludeClassUnique 17+ixClassKey              = mkPreludeClassUnique 18++typeableClassKey :: Unique+typeableClassKey        = mkPreludeClassUnique 20++monadFixClassKey :: Unique+monadFixClassKey        = mkPreludeClassUnique 28++monadFailClassKey :: Unique+monadFailClassKey       = mkPreludeClassUnique 29++monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique+monadPlusClassKey       = mkPreludeClassUnique 30+randomClassKey          = mkPreludeClassUnique 31+randomGenClassKey       = mkPreludeClassUnique 32++isStringClassKey :: Unique+isStringClassKey        = mkPreludeClassUnique 33++applicativeClassKey, foldableClassKey, traversableClassKey :: Unique+applicativeClassKey     = mkPreludeClassUnique 34+foldableClassKey        = mkPreludeClassUnique 35+traversableClassKey     = mkPreludeClassUnique 36++genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,+  selectorClassKey :: Unique+genClassKey   = mkPreludeClassUnique 37+gen1ClassKey  = mkPreludeClassUnique 38++datatypeClassKey    = mkPreludeClassUnique 39+constructorClassKey = mkPreludeClassUnique 40+selectorClassKey    = mkPreludeClassUnique 41++-- KnownNat: see Note [KnowNat & KnownSymbol and EvLit] in GHC.Tc.Types.Evidence+knownNatClassNameKey :: Unique+knownNatClassNameKey = mkPreludeClassUnique 42++-- KnownSymbol: see Note [KnownNat & KnownSymbol and EvLit] in GHC.Tc.Types.Evidence+knownSymbolClassNameKey :: Unique+knownSymbolClassNameKey = mkPreludeClassUnique 43++ghciIoClassKey :: Unique+ghciIoClassKey = mkPreludeClassUnique 44++isLabelClassNameKey :: Unique+isLabelClassNameKey = mkPreludeClassUnique 45++semigroupClassKey, monoidClassKey :: Unique+semigroupClassKey = mkPreludeClassUnique 46+monoidClassKey    = mkPreludeClassUnique 47++-- Implicit Parameters+ipClassKey :: Unique+ipClassKey = mkPreludeClassUnique 48++-- Overloaded record fields+hasFieldClassNameKey :: Unique+hasFieldClassNameKey = mkPreludeClassUnique 49+++---------------- Template Haskell -------------------+--      GHC.Builtin.Names.TH: USES ClassUniques 200-299+-----------------------------------------------------++{-+************************************************************************+*                                                                      *+\subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}+*                                                                      *+************************************************************************+-}++addrPrimTyConKey, arrayPrimTyConKey, arrayArrayPrimTyConKey, boolTyConKey,+    byteArrayPrimTyConKey, charPrimTyConKey, charTyConKey, doublePrimTyConKey,+    doubleTyConKey, floatPrimTyConKey, floatTyConKey, funTyConKey,+    intPrimTyConKey, intTyConKey, int8TyConKey, int16TyConKey,+    int8PrimTyConKey, int16PrimTyConKey, int32PrimTyConKey, int32TyConKey,+    int64PrimTyConKey, int64TyConKey,+    integerTyConKey, naturalTyConKey,+    listTyConKey, foreignObjPrimTyConKey, maybeTyConKey,+    weakPrimTyConKey, mutableArrayPrimTyConKey, mutableArrayArrayPrimTyConKey,+    mutableByteArrayPrimTyConKey, orderingTyConKey, mVarPrimTyConKey,+    ratioTyConKey, rationalTyConKey, realWorldTyConKey, stablePtrPrimTyConKey,+    stablePtrTyConKey, eqTyConKey, heqTyConKey,+    smallArrayPrimTyConKey, smallMutableArrayPrimTyConKey :: Unique+addrPrimTyConKey                        = mkPreludeTyConUnique  1+arrayPrimTyConKey                       = mkPreludeTyConUnique  3+boolTyConKey                            = mkPreludeTyConUnique  4+byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5+charPrimTyConKey                        = mkPreludeTyConUnique  7+charTyConKey                            = mkPreludeTyConUnique  8+doublePrimTyConKey                      = mkPreludeTyConUnique  9+doubleTyConKey                          = mkPreludeTyConUnique 10+floatPrimTyConKey                       = mkPreludeTyConUnique 11+floatTyConKey                           = mkPreludeTyConUnique 12+funTyConKey                             = mkPreludeTyConUnique 13+intPrimTyConKey                         = mkPreludeTyConUnique 14+intTyConKey                             = mkPreludeTyConUnique 15+int8PrimTyConKey                        = mkPreludeTyConUnique 16+int8TyConKey                            = mkPreludeTyConUnique 17+int16PrimTyConKey                       = mkPreludeTyConUnique 18+int16TyConKey                           = mkPreludeTyConUnique 19+int32PrimTyConKey                       = mkPreludeTyConUnique 20+int32TyConKey                           = mkPreludeTyConUnique 21+int64PrimTyConKey                       = mkPreludeTyConUnique 22+int64TyConKey                           = mkPreludeTyConUnique 23+integerTyConKey                         = mkPreludeTyConUnique 24+naturalTyConKey                         = mkPreludeTyConUnique 25++listTyConKey                            = mkPreludeTyConUnique 26+foreignObjPrimTyConKey                  = mkPreludeTyConUnique 27+maybeTyConKey                           = mkPreludeTyConUnique 28+weakPrimTyConKey                        = mkPreludeTyConUnique 29+mutableArrayPrimTyConKey                = mkPreludeTyConUnique 30+mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 31+orderingTyConKey                        = mkPreludeTyConUnique 32+mVarPrimTyConKey                        = mkPreludeTyConUnique 33+ratioTyConKey                           = mkPreludeTyConUnique 34+rationalTyConKey                        = mkPreludeTyConUnique 35+realWorldTyConKey                       = mkPreludeTyConUnique 36+stablePtrPrimTyConKey                   = mkPreludeTyConUnique 37+stablePtrTyConKey                       = mkPreludeTyConUnique 38+eqTyConKey                              = mkPreludeTyConUnique 40+heqTyConKey                             = mkPreludeTyConUnique 41+arrayArrayPrimTyConKey                  = mkPreludeTyConUnique 42+mutableArrayArrayPrimTyConKey           = mkPreludeTyConUnique 43++statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,+    mutVarPrimTyConKey, ioTyConKey,+    wordPrimTyConKey, wordTyConKey, word8PrimTyConKey, word8TyConKey,+    word16PrimTyConKey, word16TyConKey, word32PrimTyConKey, word32TyConKey,+    word64PrimTyConKey, word64TyConKey,+    liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,+    typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,+    funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,+    eqReprPrimTyConKey, eqPhantPrimTyConKey, voidPrimTyConKey,+    compactPrimTyConKey :: Unique+statePrimTyConKey                       = mkPreludeTyConUnique 50+stableNamePrimTyConKey                  = mkPreludeTyConUnique 51+stableNameTyConKey                      = mkPreludeTyConUnique 52+eqPrimTyConKey                          = mkPreludeTyConUnique 53+eqReprPrimTyConKey                      = mkPreludeTyConUnique 54+eqPhantPrimTyConKey                     = mkPreludeTyConUnique 55+mutVarPrimTyConKey                      = mkPreludeTyConUnique 56+ioTyConKey                              = mkPreludeTyConUnique 57+voidPrimTyConKey                        = mkPreludeTyConUnique 58+wordPrimTyConKey                        = mkPreludeTyConUnique 59+wordTyConKey                            = mkPreludeTyConUnique 60+word8PrimTyConKey                       = mkPreludeTyConUnique 61+word8TyConKey                           = mkPreludeTyConUnique 62+word16PrimTyConKey                      = mkPreludeTyConUnique 63+word16TyConKey                          = mkPreludeTyConUnique 64+word32PrimTyConKey                      = mkPreludeTyConUnique 65+word32TyConKey                          = mkPreludeTyConUnique 66+word64PrimTyConKey                      = mkPreludeTyConUnique 67+word64TyConKey                          = mkPreludeTyConUnique 68+liftedConKey                            = mkPreludeTyConUnique 69+unliftedConKey                          = mkPreludeTyConUnique 70+anyBoxConKey                            = mkPreludeTyConUnique 71+kindConKey                              = mkPreludeTyConUnique 72+boxityConKey                            = mkPreludeTyConUnique 73+typeConKey                              = mkPreludeTyConUnique 74+threadIdPrimTyConKey                    = mkPreludeTyConUnique 75+bcoPrimTyConKey                         = mkPreludeTyConUnique 76+ptrTyConKey                             = mkPreludeTyConUnique 77+funPtrTyConKey                          = mkPreludeTyConUnique 78+tVarPrimTyConKey                        = mkPreludeTyConUnique 79+compactPrimTyConKey                     = mkPreludeTyConUnique 80++eitherTyConKey :: Unique+eitherTyConKey                          = mkPreludeTyConUnique 84++-- Kind constructors+liftedTypeKindTyConKey, tYPETyConKey,+  constraintKindTyConKey, runtimeRepTyConKey,+  vecCountTyConKey, vecElemTyConKey :: Unique+liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87+tYPETyConKey                            = mkPreludeTyConUnique 88+constraintKindTyConKey                  = mkPreludeTyConUnique 92+runtimeRepTyConKey                      = mkPreludeTyConUnique 95+vecCountTyConKey                        = mkPreludeTyConUnique 96+vecElemTyConKey                         = mkPreludeTyConUnique 97++pluginTyConKey, frontendPluginTyConKey :: Unique+pluginTyConKey                          = mkPreludeTyConUnique 102+frontendPluginTyConKey                  = mkPreludeTyConUnique 103++unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,+    opaqueTyConKey :: Unique+unknownTyConKey                         = mkPreludeTyConUnique 129+unknown1TyConKey                        = mkPreludeTyConUnique 130+unknown2TyConKey                        = mkPreludeTyConUnique 131+unknown3TyConKey                        = mkPreludeTyConUnique 132+opaqueTyConKey                          = mkPreludeTyConUnique 133++-- Generics (Unique keys)+v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,+  k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,+  compTyConKey, rTyConKey, dTyConKey,+  cTyConKey, sTyConKey, rec0TyConKey,+  d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,+  repTyConKey, rep1TyConKey, uRecTyConKey,+  uAddrTyConKey, uCharTyConKey, uDoubleTyConKey,+  uFloatTyConKey, uIntTyConKey, uWordTyConKey :: Unique++v1TyConKey    = mkPreludeTyConUnique 135+u1TyConKey    = mkPreludeTyConUnique 136+par1TyConKey  = mkPreludeTyConUnique 137+rec1TyConKey  = mkPreludeTyConUnique 138+k1TyConKey    = mkPreludeTyConUnique 139+m1TyConKey    = mkPreludeTyConUnique 140++sumTyConKey   = mkPreludeTyConUnique 141+prodTyConKey  = mkPreludeTyConUnique 142+compTyConKey  = mkPreludeTyConUnique 143++rTyConKey = mkPreludeTyConUnique 144+dTyConKey = mkPreludeTyConUnique 146+cTyConKey = mkPreludeTyConUnique 147+sTyConKey = mkPreludeTyConUnique 148++rec0TyConKey  = mkPreludeTyConUnique 149+d1TyConKey    = mkPreludeTyConUnique 151+c1TyConKey    = mkPreludeTyConUnique 152+s1TyConKey    = mkPreludeTyConUnique 153+noSelTyConKey = mkPreludeTyConUnique 154++repTyConKey  = mkPreludeTyConUnique 155+rep1TyConKey = mkPreludeTyConUnique 156++uRecTyConKey    = mkPreludeTyConUnique 157+uAddrTyConKey   = mkPreludeTyConUnique 158+uCharTyConKey   = mkPreludeTyConUnique 159+uDoubleTyConKey = mkPreludeTyConUnique 160+uFloatTyConKey  = mkPreludeTyConUnique 161+uIntTyConKey    = mkPreludeTyConUnique 162+uWordTyConKey   = mkPreludeTyConUnique 163++-- Type-level naturals+typeNatKindConNameKey, typeSymbolKindConNameKey,+  typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey,+  typeNatLeqTyFamNameKey, typeNatSubTyFamNameKey+  , typeSymbolCmpTyFamNameKey, typeNatCmpTyFamNameKey+  , typeNatDivTyFamNameKey+  , typeNatModTyFamNameKey+  , typeNatLogTyFamNameKey+  :: Unique+typeNatKindConNameKey     = mkPreludeTyConUnique 164+typeSymbolKindConNameKey  = mkPreludeTyConUnique 165+typeNatAddTyFamNameKey    = mkPreludeTyConUnique 166+typeNatMulTyFamNameKey    = mkPreludeTyConUnique 167+typeNatExpTyFamNameKey    = mkPreludeTyConUnique 168+typeNatLeqTyFamNameKey    = mkPreludeTyConUnique 169+typeNatSubTyFamNameKey    = mkPreludeTyConUnique 170+typeSymbolCmpTyFamNameKey = mkPreludeTyConUnique 171+typeNatCmpTyFamNameKey    = mkPreludeTyConUnique 172+typeNatDivTyFamNameKey  = mkPreludeTyConUnique 173+typeNatModTyFamNameKey  = mkPreludeTyConUnique 174+typeNatLogTyFamNameKey  = mkPreludeTyConUnique 175++-- Custom user type-errors+errorMessageTypeErrorFamKey :: Unique+errorMessageTypeErrorFamKey =  mkPreludeTyConUnique 176++++ntTyConKey:: Unique+ntTyConKey = mkPreludeTyConUnique 177+coercibleTyConKey :: Unique+coercibleTyConKey = mkPreludeTyConUnique 178++proxyPrimTyConKey :: Unique+proxyPrimTyConKey = mkPreludeTyConUnique 179++specTyConKey :: Unique+specTyConKey = mkPreludeTyConUnique 180++anyTyConKey :: Unique+anyTyConKey = mkPreludeTyConUnique 181++smallArrayPrimTyConKey        = mkPreludeTyConUnique  182+smallMutableArrayPrimTyConKey = mkPreludeTyConUnique  183++staticPtrTyConKey  :: Unique+staticPtrTyConKey  = mkPreludeTyConUnique 184++staticPtrInfoTyConKey :: Unique+staticPtrInfoTyConKey = mkPreludeTyConUnique 185++callStackTyConKey :: Unique+callStackTyConKey = mkPreludeTyConUnique 186++-- Typeables+typeRepTyConKey, someTypeRepTyConKey, someTypeRepDataConKey :: Unique+typeRepTyConKey       = mkPreludeTyConUnique 187+someTypeRepTyConKey   = mkPreludeTyConUnique 188+someTypeRepDataConKey = mkPreludeTyConUnique 189+++typeSymbolAppendFamNameKey :: Unique+typeSymbolAppendFamNameKey = mkPreludeTyConUnique 190++-- Unsafe equality+unsafeEqualityTyConKey :: Unique+unsafeEqualityTyConKey = mkPreludeTyConUnique 191+++---------------- Template Haskell -------------------+--      GHC.Builtin.Names.TH: USES TyConUniques 200-299+-----------------------------------------------------++----------------------- SIMD ------------------------+--      USES TyConUniques 300-399+-----------------------------------------------------++#include "primop-vector-uniques.hs-incl"++{-+************************************************************************+*                                                                      *+\subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}+*                                                                      *+************************************************************************+-}++charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,+    floatDataConKey, intDataConKey, integerSDataConKey, nilDataConKey,+    ratioDataConKey, stableNameDataConKey, trueDataConKey, wordDataConKey,+    word8DataConKey, ioDataConKey, integerDataConKey, heqDataConKey,+    coercibleDataConKey, eqDataConKey, nothingDataConKey, justDataConKey :: Unique++charDataConKey                          = mkPreludeDataConUnique  1+consDataConKey                          = mkPreludeDataConUnique  2+doubleDataConKey                        = mkPreludeDataConUnique  3+falseDataConKey                         = mkPreludeDataConUnique  4+floatDataConKey                         = mkPreludeDataConUnique  5+intDataConKey                           = mkPreludeDataConUnique  6+integerSDataConKey                      = mkPreludeDataConUnique  7+nothingDataConKey                       = mkPreludeDataConUnique  8+justDataConKey                          = mkPreludeDataConUnique  9+eqDataConKey                            = mkPreludeDataConUnique 10+nilDataConKey                           = mkPreludeDataConUnique 11+ratioDataConKey                         = mkPreludeDataConUnique 12+word8DataConKey                         = mkPreludeDataConUnique 13+stableNameDataConKey                    = mkPreludeDataConUnique 14+trueDataConKey                          = mkPreludeDataConUnique 15+wordDataConKey                          = mkPreludeDataConUnique 16+ioDataConKey                            = mkPreludeDataConUnique 17+integerDataConKey                       = mkPreludeDataConUnique 18+heqDataConKey                           = mkPreludeDataConUnique 19++-- Generic data constructors+crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique+crossDataConKey                         = mkPreludeDataConUnique 20+inlDataConKey                           = mkPreludeDataConUnique 21+inrDataConKey                           = mkPreludeDataConUnique 22+genUnitDataConKey                       = mkPreludeDataConUnique 23++leftDataConKey, rightDataConKey :: Unique+leftDataConKey                          = mkPreludeDataConUnique 25+rightDataConKey                         = mkPreludeDataConUnique 26++ordLTDataConKey, ordEQDataConKey, ordGTDataConKey :: Unique+ordLTDataConKey                         = mkPreludeDataConUnique 27+ordEQDataConKey                         = mkPreludeDataConUnique 28+ordGTDataConKey                         = mkPreludeDataConUnique 29+++coercibleDataConKey                     = mkPreludeDataConUnique 32++staticPtrDataConKey :: Unique+staticPtrDataConKey                     = mkPreludeDataConUnique 33++staticPtrInfoDataConKey :: Unique+staticPtrInfoDataConKey                 = mkPreludeDataConUnique 34++fingerprintDataConKey :: Unique+fingerprintDataConKey                   = mkPreludeDataConUnique 35++srcLocDataConKey :: Unique+srcLocDataConKey                        = mkPreludeDataConUnique 37++trTyConTyConKey, trTyConDataConKey,+  trModuleTyConKey, trModuleDataConKey,+  trNameTyConKey, trNameSDataConKey, trNameDDataConKey,+  trGhcPrimModuleKey, kindRepTyConKey,+  typeLitSortTyConKey :: Unique+trTyConTyConKey                         = mkPreludeDataConUnique 40+trTyConDataConKey                       = mkPreludeDataConUnique 41+trModuleTyConKey                        = mkPreludeDataConUnique 42+trModuleDataConKey                      = mkPreludeDataConUnique 43+trNameTyConKey                          = mkPreludeDataConUnique 44+trNameSDataConKey                       = mkPreludeDataConUnique 45+trNameDDataConKey                       = mkPreludeDataConUnique 46+trGhcPrimModuleKey                      = mkPreludeDataConUnique 47+kindRepTyConKey                         = mkPreludeDataConUnique 48+typeLitSortTyConKey                     = mkPreludeDataConUnique 49++typeErrorTextDataConKey,+  typeErrorAppendDataConKey,+  typeErrorVAppendDataConKey,+  typeErrorShowTypeDataConKey+  :: Unique+typeErrorTextDataConKey                 = mkPreludeDataConUnique 50+typeErrorAppendDataConKey               = mkPreludeDataConUnique 51+typeErrorVAppendDataConKey              = mkPreludeDataConUnique 52+typeErrorShowTypeDataConKey             = mkPreludeDataConUnique 53++prefixIDataConKey, infixIDataConKey, leftAssociativeDataConKey,+    rightAssociativeDataConKey, notAssociativeDataConKey,+    sourceUnpackDataConKey, sourceNoUnpackDataConKey,+    noSourceUnpackednessDataConKey, sourceLazyDataConKey,+    sourceStrictDataConKey, noSourceStrictnessDataConKey,+    decidedLazyDataConKey, decidedStrictDataConKey, decidedUnpackDataConKey,+    metaDataDataConKey, metaConsDataConKey, metaSelDataConKey :: Unique+prefixIDataConKey                       = mkPreludeDataConUnique 54+infixIDataConKey                        = mkPreludeDataConUnique 55+leftAssociativeDataConKey               = mkPreludeDataConUnique 56+rightAssociativeDataConKey              = mkPreludeDataConUnique 57+notAssociativeDataConKey                = mkPreludeDataConUnique 58+sourceUnpackDataConKey                  = mkPreludeDataConUnique 59+sourceNoUnpackDataConKey                = mkPreludeDataConUnique 60+noSourceUnpackednessDataConKey          = mkPreludeDataConUnique 61+sourceLazyDataConKey                    = mkPreludeDataConUnique 62+sourceStrictDataConKey                  = mkPreludeDataConUnique 63+noSourceStrictnessDataConKey            = mkPreludeDataConUnique 64+decidedLazyDataConKey                   = mkPreludeDataConUnique 65+decidedStrictDataConKey                 = mkPreludeDataConUnique 66+decidedUnpackDataConKey                 = mkPreludeDataConUnique 67+metaDataDataConKey                      = mkPreludeDataConUnique 68+metaConsDataConKey                      = mkPreludeDataConUnique 69+metaSelDataConKey                       = mkPreludeDataConUnique 70++vecRepDataConKey, tupleRepDataConKey, sumRepDataConKey :: Unique+vecRepDataConKey                        = mkPreludeDataConUnique 71+tupleRepDataConKey                      = mkPreludeDataConUnique 72+sumRepDataConKey                        = mkPreludeDataConUnique 73++-- See Note [Wiring in RuntimeRep] in GHC.Builtin.Types+runtimeRepSimpleDataConKeys, unliftedSimpleRepDataConKeys, unliftedRepDataConKeys :: [Unique]+liftedRepDataConKey :: Unique+runtimeRepSimpleDataConKeys@(liftedRepDataConKey : unliftedSimpleRepDataConKeys)+  = map mkPreludeDataConUnique [74..88]++unliftedRepDataConKeys = vecRepDataConKey :+                         tupleRepDataConKey :+                         sumRepDataConKey :+                         unliftedSimpleRepDataConKeys++-- See Note [Wiring in RuntimeRep] in GHC.Builtin.Types+-- VecCount+vecCountDataConKeys :: [Unique]+vecCountDataConKeys = map mkPreludeDataConUnique [89..94]++-- See Note [Wiring in RuntimeRep] in GHC.Builtin.Types+-- VecElem+vecElemDataConKeys :: [Unique]+vecElemDataConKeys = map mkPreludeDataConUnique [95..104]++-- Typeable things+kindRepTyConAppDataConKey, kindRepVarDataConKey, kindRepAppDataConKey,+    kindRepFunDataConKey, kindRepTYPEDataConKey,+    kindRepTypeLitSDataConKey, kindRepTypeLitDDataConKey+    :: Unique+kindRepTyConAppDataConKey = mkPreludeDataConUnique 105+kindRepVarDataConKey      = mkPreludeDataConUnique 106+kindRepAppDataConKey      = mkPreludeDataConUnique 107+kindRepFunDataConKey      = mkPreludeDataConUnique 108+kindRepTYPEDataConKey     = mkPreludeDataConUnique 109+kindRepTypeLitSDataConKey = mkPreludeDataConUnique 110+kindRepTypeLitDDataConKey = mkPreludeDataConUnique 111++typeLitSymbolDataConKey, typeLitNatDataConKey :: Unique+typeLitSymbolDataConKey   = mkPreludeDataConUnique 112+typeLitNatDataConKey      = mkPreludeDataConUnique 113++-- Unsafe equality+unsafeReflDataConKey :: Unique+unsafeReflDataConKey      = mkPreludeDataConUnique 114++---------------- Template Haskell -------------------+--      GHC.Builtin.Names.TH: USES DataUniques 200-250+-----------------------------------------------------+++{-+************************************************************************+*                                                                      *+\subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}+*                                                                      *+************************************************************************+-}++wildCardKey, absentErrorIdKey, augmentIdKey, appendIdKey,+    buildIdKey, errorIdKey, foldrIdKey, recSelErrorIdKey,+    seqIdKey, eqStringIdKey,+    noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,+    runtimeErrorIdKey, patErrorIdKey, voidPrimIdKey,+    realWorldPrimIdKey, recConErrorIdKey,+    unpackCStringUtf8IdKey, unpackCStringAppendIdKey,+    unpackCStringFoldrIdKey, unpackCStringIdKey,+    typeErrorIdKey, divIntIdKey, modIntIdKey,+    absentSumFieldErrorIdKey :: Unique++wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard binders]+absentErrorIdKey              = mkPreludeMiscIdUnique  1+augmentIdKey                  = mkPreludeMiscIdUnique  2+appendIdKey                   = mkPreludeMiscIdUnique  3+buildIdKey                    = mkPreludeMiscIdUnique  4+errorIdKey                    = mkPreludeMiscIdUnique  5+foldrIdKey                    = mkPreludeMiscIdUnique  6+recSelErrorIdKey              = mkPreludeMiscIdUnique  7+seqIdKey                      = mkPreludeMiscIdUnique  8+absentSumFieldErrorIdKey      = mkPreludeMiscIdUnique  9+eqStringIdKey                 = mkPreludeMiscIdUnique 10+noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 11+nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 12+runtimeErrorIdKey             = mkPreludeMiscIdUnique 13+patErrorIdKey                 = mkPreludeMiscIdUnique 14+realWorldPrimIdKey            = mkPreludeMiscIdUnique 15+recConErrorIdKey              = mkPreludeMiscIdUnique 16+unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 17+unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 18+unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 19+unpackCStringIdKey            = mkPreludeMiscIdUnique 20+voidPrimIdKey                 = mkPreludeMiscIdUnique 21+typeErrorIdKey                = mkPreludeMiscIdUnique 22+divIntIdKey                   = mkPreludeMiscIdUnique 23+modIntIdKey                   = mkPreludeMiscIdUnique 24++concatIdKey, filterIdKey, zipIdKey,+    bindIOIdKey, returnIOIdKey, newStablePtrIdKey,+    printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,+    fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey :: Unique+concatIdKey                   = mkPreludeMiscIdUnique 31+filterIdKey                   = mkPreludeMiscIdUnique 32+zipIdKey                      = mkPreludeMiscIdUnique 33+bindIOIdKey                   = mkPreludeMiscIdUnique 34+returnIOIdKey                 = mkPreludeMiscIdUnique 35+newStablePtrIdKey             = mkPreludeMiscIdUnique 36+printIdKey                    = mkPreludeMiscIdUnique 37+failIOIdKey                   = mkPreludeMiscIdUnique 38+nullAddrIdKey                 = mkPreludeMiscIdUnique 39+voidArgIdKey                  = mkPreludeMiscIdUnique 40+fstIdKey                      = mkPreludeMiscIdUnique 41+sndIdKey                      = mkPreludeMiscIdUnique 42+otherwiseIdKey                = mkPreludeMiscIdUnique 43+assertIdKey                   = mkPreludeMiscIdUnique 44++mkIntegerIdKey, smallIntegerIdKey, wordToIntegerIdKey,+    integerToWordIdKey, integerToIntIdKey,+    integerToWord64IdKey, integerToInt64IdKey,+    word64ToIntegerIdKey, int64ToIntegerIdKey,+    plusIntegerIdKey, timesIntegerIdKey, minusIntegerIdKey,+    negateIntegerIdKey,+    eqIntegerPrimIdKey, neqIntegerPrimIdKey, absIntegerIdKey, signumIntegerIdKey,+    leIntegerPrimIdKey, gtIntegerPrimIdKey, ltIntegerPrimIdKey, geIntegerPrimIdKey,+    compareIntegerIdKey, quotRemIntegerIdKey, divModIntegerIdKey,+    quotIntegerIdKey, remIntegerIdKey, divIntegerIdKey, modIntegerIdKey,+    floatFromIntegerIdKey, doubleFromIntegerIdKey,+    encodeFloatIntegerIdKey, encodeDoubleIntegerIdKey,+    decodeDoubleIntegerIdKey,+    gcdIntegerIdKey, lcmIntegerIdKey,+    andIntegerIdKey, orIntegerIdKey, xorIntegerIdKey, complementIntegerIdKey,+    shiftLIntegerIdKey, shiftRIntegerIdKey :: Unique+mkIntegerIdKey                = mkPreludeMiscIdUnique 60+smallIntegerIdKey             = mkPreludeMiscIdUnique 61+integerToWordIdKey            = mkPreludeMiscIdUnique 62+integerToIntIdKey             = mkPreludeMiscIdUnique 63+integerToWord64IdKey          = mkPreludeMiscIdUnique 64+integerToInt64IdKey           = mkPreludeMiscIdUnique 65+plusIntegerIdKey              = mkPreludeMiscIdUnique 66+timesIntegerIdKey             = mkPreludeMiscIdUnique 67+minusIntegerIdKey             = mkPreludeMiscIdUnique 68+negateIntegerIdKey            = mkPreludeMiscIdUnique 69+eqIntegerPrimIdKey            = mkPreludeMiscIdUnique 70+neqIntegerPrimIdKey           = mkPreludeMiscIdUnique 71+absIntegerIdKey               = mkPreludeMiscIdUnique 72+signumIntegerIdKey            = mkPreludeMiscIdUnique 73+leIntegerPrimIdKey            = mkPreludeMiscIdUnique 74+gtIntegerPrimIdKey            = mkPreludeMiscIdUnique 75+ltIntegerPrimIdKey            = mkPreludeMiscIdUnique 76+geIntegerPrimIdKey            = mkPreludeMiscIdUnique 77+compareIntegerIdKey           = mkPreludeMiscIdUnique 78+quotIntegerIdKey              = mkPreludeMiscIdUnique 79+remIntegerIdKey               = mkPreludeMiscIdUnique 80+divIntegerIdKey               = mkPreludeMiscIdUnique 81+modIntegerIdKey               = mkPreludeMiscIdUnique 82+divModIntegerIdKey            = mkPreludeMiscIdUnique 83+quotRemIntegerIdKey           = mkPreludeMiscIdUnique 84+floatFromIntegerIdKey         = mkPreludeMiscIdUnique 85+doubleFromIntegerIdKey        = mkPreludeMiscIdUnique 86+encodeFloatIntegerIdKey       = mkPreludeMiscIdUnique 87+encodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 88+gcdIntegerIdKey               = mkPreludeMiscIdUnique 89+lcmIntegerIdKey               = mkPreludeMiscIdUnique 90+andIntegerIdKey               = mkPreludeMiscIdUnique 91+orIntegerIdKey                = mkPreludeMiscIdUnique 92+xorIntegerIdKey               = mkPreludeMiscIdUnique 93+complementIntegerIdKey        = mkPreludeMiscIdUnique 94+shiftLIntegerIdKey            = mkPreludeMiscIdUnique 95+shiftRIntegerIdKey            = mkPreludeMiscIdUnique 96+wordToIntegerIdKey            = mkPreludeMiscIdUnique 97+word64ToIntegerIdKey          = mkPreludeMiscIdUnique 98+int64ToIntegerIdKey           = mkPreludeMiscIdUnique 99+decodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 100++rootMainKey, runMainKey :: Unique+rootMainKey                   = mkPreludeMiscIdUnique 101+runMainKey                    = mkPreludeMiscIdUnique 102++thenIOIdKey, lazyIdKey, assertErrorIdKey, oneShotKey, runRWKey :: Unique+thenIOIdKey                   = mkPreludeMiscIdUnique 103+lazyIdKey                     = mkPreludeMiscIdUnique 104+assertErrorIdKey              = mkPreludeMiscIdUnique 105+oneShotKey                    = mkPreludeMiscIdUnique 106+runRWKey                      = mkPreludeMiscIdUnique 107++traceKey :: Unique+traceKey                      = mkPreludeMiscIdUnique 108++breakpointIdKey, breakpointCondIdKey :: Unique+breakpointIdKey               = mkPreludeMiscIdUnique 110+breakpointCondIdKey           = mkPreludeMiscIdUnique 111++inlineIdKey, noinlineIdKey :: Unique+inlineIdKey                   = mkPreludeMiscIdUnique 120+-- see below++mapIdKey, groupWithIdKey, dollarIdKey :: Unique+mapIdKey              = mkPreludeMiscIdUnique 121+groupWithIdKey        = mkPreludeMiscIdUnique 122+dollarIdKey           = mkPreludeMiscIdUnique 123++coercionTokenIdKey :: Unique+coercionTokenIdKey    = mkPreludeMiscIdUnique 124++noinlineIdKey                 = mkPreludeMiscIdUnique 125++rationalToFloatIdKey, rationalToDoubleIdKey :: Unique+rationalToFloatIdKey   = mkPreludeMiscIdUnique 130+rationalToDoubleIdKey  = mkPreludeMiscIdUnique 131++magicDictKey :: Unique+magicDictKey                  = mkPreludeMiscIdUnique 156++coerceKey :: Unique+coerceKey                     = mkPreludeMiscIdUnique 157++{-+Certain class operations from Prelude classes.  They get their own+uniques so we can look them up easily when we want to conjure them up+during type checking.+-}++-- Just a placeholder for unbound variables produced by the renamer:+unboundKey :: Unique+unboundKey                    = mkPreludeMiscIdUnique 158++fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,+    enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,+    enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,+    bindMClassOpKey, thenMClassOpKey, returnMClassOpKey, fmapClassOpKey+    :: Unique+fromIntegerClassOpKey         = mkPreludeMiscIdUnique 160+minusClassOpKey               = mkPreludeMiscIdUnique 161+fromRationalClassOpKey        = mkPreludeMiscIdUnique 162+enumFromClassOpKey            = mkPreludeMiscIdUnique 163+enumFromThenClassOpKey        = mkPreludeMiscIdUnique 164+enumFromToClassOpKey          = mkPreludeMiscIdUnique 165+enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 166+eqClassOpKey                  = mkPreludeMiscIdUnique 167+geClassOpKey                  = mkPreludeMiscIdUnique 168+negateClassOpKey              = mkPreludeMiscIdUnique 169+bindMClassOpKey               = mkPreludeMiscIdUnique 171 -- (>>=)+thenMClassOpKey               = mkPreludeMiscIdUnique 172 -- (>>)+fmapClassOpKey                = mkPreludeMiscIdUnique 173+returnMClassOpKey             = mkPreludeMiscIdUnique 174++-- Recursive do notation+mfixIdKey :: Unique+mfixIdKey       = mkPreludeMiscIdUnique 175++-- MonadFail operations+failMClassOpKey :: Unique+failMClassOpKey = mkPreludeMiscIdUnique 176++-- Arrow notation+arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,+    loopAIdKey :: Unique+arrAIdKey       = mkPreludeMiscIdUnique 180+composeAIdKey   = mkPreludeMiscIdUnique 181 -- >>>+firstAIdKey     = mkPreludeMiscIdUnique 182+appAIdKey       = mkPreludeMiscIdUnique 183+choiceAIdKey    = mkPreludeMiscIdUnique 184 --  |||+loopAIdKey      = mkPreludeMiscIdUnique 185++fromStringClassOpKey :: Unique+fromStringClassOpKey          = mkPreludeMiscIdUnique 186++-- Annotation type checking+toAnnotationWrapperIdKey :: Unique+toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 187++-- Conversion functions+fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique+fromIntegralIdKey    = mkPreludeMiscIdUnique 190+realToFracIdKey      = mkPreludeMiscIdUnique 191+toIntegerClassOpKey  = mkPreludeMiscIdUnique 192+toRationalClassOpKey = mkPreludeMiscIdUnique 193++-- Monad comprehensions+guardMIdKey, liftMIdKey, mzipIdKey :: Unique+guardMIdKey     = mkPreludeMiscIdUnique 194+liftMIdKey      = mkPreludeMiscIdUnique 195+mzipIdKey       = mkPreludeMiscIdUnique 196++-- GHCi+ghciStepIoMClassOpKey :: Unique+ghciStepIoMClassOpKey = mkPreludeMiscIdUnique 197++-- Overloaded lists+isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: Unique+isListClassKey = mkPreludeMiscIdUnique 198+fromListClassOpKey = mkPreludeMiscIdUnique 199+fromListNClassOpKey = mkPreludeMiscIdUnique 500+toListClassOpKey = mkPreludeMiscIdUnique 501++proxyHashKey :: Unique+proxyHashKey = mkPreludeMiscIdUnique 502++---------------- Template Haskell -------------------+--      GHC.Builtin.Names.TH: USES IdUniques 200-499+-----------------------------------------------------++-- Used to make `Typeable` dictionaries+mkTyConKey+  , mkTrTypeKey+  , mkTrConKey+  , mkTrAppKey+  , mkTrFunKey+  , typeNatTypeRepKey+  , typeSymbolTypeRepKey+  , typeRepIdKey+  :: Unique+mkTyConKey            = mkPreludeMiscIdUnique 503+mkTrTypeKey           = mkPreludeMiscIdUnique 504+mkTrConKey            = mkPreludeMiscIdUnique 505+mkTrAppKey            = mkPreludeMiscIdUnique 506+typeNatTypeRepKey     = mkPreludeMiscIdUnique 507+typeSymbolTypeRepKey  = mkPreludeMiscIdUnique 508+typeRepIdKey          = mkPreludeMiscIdUnique 509+mkTrFunKey            = mkPreludeMiscIdUnique 510++-- Representations for primitive types+trTYPEKey+  ,trTYPE'PtrRepLiftedKey+  , trRuntimeRepKey+  , tr'PtrRepLiftedKey+  :: Unique+trTYPEKey              = mkPreludeMiscIdUnique 511+trTYPE'PtrRepLiftedKey = mkPreludeMiscIdUnique 512+trRuntimeRepKey        = mkPreludeMiscIdUnique 513+tr'PtrRepLiftedKey     = mkPreludeMiscIdUnique 514++-- KindReps for common cases+starKindRepKey, starArrStarKindRepKey, starArrStarArrStarKindRepKey :: Unique+starKindRepKey        = mkPreludeMiscIdUnique 520+starArrStarKindRepKey = mkPreludeMiscIdUnique 521+starArrStarArrStarKindRepKey = mkPreludeMiscIdUnique 522++-- Dynamic+toDynIdKey :: Unique+toDynIdKey            = mkPreludeMiscIdUnique 523+++bitIntegerIdKey :: Unique+bitIntegerIdKey       = mkPreludeMiscIdUnique 550++heqSCSelIdKey, eqSCSelIdKey, coercibleSCSelIdKey :: Unique+eqSCSelIdKey        = mkPreludeMiscIdUnique 551+heqSCSelIdKey       = mkPreludeMiscIdUnique 552+coercibleSCSelIdKey = mkPreludeMiscIdUnique 553++sappendClassOpKey :: Unique+sappendClassOpKey = mkPreludeMiscIdUnique 554++memptyClassOpKey, mappendClassOpKey, mconcatClassOpKey :: Unique+memptyClassOpKey  = mkPreludeMiscIdUnique 555+mappendClassOpKey = mkPreludeMiscIdUnique 556+mconcatClassOpKey = mkPreludeMiscIdUnique 557++emptyCallStackKey, pushCallStackKey :: Unique+emptyCallStackKey = mkPreludeMiscIdUnique 558+pushCallStackKey  = mkPreludeMiscIdUnique 559++fromStaticPtrClassOpKey :: Unique+fromStaticPtrClassOpKey = mkPreludeMiscIdUnique 560++makeStaticKey :: Unique+makeStaticKey = mkPreludeMiscIdUnique 561++-- Natural+naturalFromIntegerIdKey, naturalToIntegerIdKey, plusNaturalIdKey,+   minusNaturalIdKey, timesNaturalIdKey, mkNaturalIdKey,+   naturalSDataConKey, wordToNaturalIdKey :: Unique+naturalFromIntegerIdKey = mkPreludeMiscIdUnique 562+naturalToIntegerIdKey   = mkPreludeMiscIdUnique 563+plusNaturalIdKey        = mkPreludeMiscIdUnique 564+minusNaturalIdKey       = mkPreludeMiscIdUnique 565+timesNaturalIdKey       = mkPreludeMiscIdUnique 566+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++{-+************************************************************************+*                                                                      *+\subsection[Class-std-groups]{Standard groups of Prelude classes}+*                                                                      *+************************************************************************++NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@+even though every numeric class has these two as a superclass,+because the list of ambiguous dictionaries hasn't been simplified.+-}++numericClassKeys :: [Unique]+numericClassKeys =+        [ numClassKey+        , realClassKey+        , integralClassKey+        ]+        ++ fractionalClassKeys++fractionalClassKeys :: [Unique]+fractionalClassKeys =+        [ fractionalClassKey+        , floatingClassKey+        , realFracClassKey+        , realFloatClassKey+        ]++-- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),+-- and are: "classes defined in the Prelude or a standard library"+standardClassKeys :: [Unique]+standardClassKeys = derivableClassKeys ++ numericClassKeys+                  ++ [randomClassKey, randomGenClassKey,+                      functorClassKey,+                      monadClassKey, monadPlusClassKey, monadFailClassKey,+                      semigroupClassKey, monoidClassKey,+                      isStringClassKey,+                      applicativeClassKey, foldableClassKey,+                      traversableClassKey, alternativeClassKey+                     ]++{-+@derivableClassKeys@ is also used in checking \tr{deriving} constructs+(@GHC.Tc.Deriv@).+-}++derivableClassKeys :: [Unique]+derivableClassKeys+  = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,+      boundedClassKey, showClassKey, readClassKey ]+++-- These are the "interactive classes" that are consulted when doing+-- defaulting. Does not include Num or IsString, which have special+-- handling.+interactiveClassNames :: [Name]+interactiveClassNames+  = [ showClassName, eqClassName, ordClassName, foldableClassName+    , traversableClassName ]++interactiveClassKeys :: [Unique]+interactiveClassKeys = map getUnique interactiveClassNames++{-+************************************************************************+*                                                                      *+   Semi-builtin names+*                                                                      *+************************************************************************++The following names should be considered by GHCi to be in scope always.++-}++pretendNameIsInScope :: Name -> Bool+pretendNameIsInScope n+  = any (n `hasKey`)+    [ liftedTypeKindTyConKey, tYPETyConKey+    , runtimeRepTyConKey, liftedRepDataConKey ]
+ compiler/GHC/Builtin/Names.hs-boot view
@@ -0,0 +1,7 @@+module GHC.Builtin.Names where++import GHC.Unit.Module+import GHC.Types.Unique++mAIN :: Module+liftedTypeKindTyConKey :: Unique
+ compiler/GHC/Builtin/PrimOps.hs view
@@ -0,0 +1,711 @@+{-+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++\section[PrimOp]{Primitive operations (machine-level)}+-}++{-# LANGUAGE CPP #-}++module GHC.Builtin.PrimOps (+        PrimOp(..), PrimOpVecCat(..), allThePrimOps,+        primOpType, primOpSig,+        primOpTag, maxPrimOpTag, primOpOcc,+        primOpWrapperId,++        tagToEnumKey,++        primOpOutOfLine, primOpCodeSize,+        primOpOkForSpeculation, primOpOkForSideEffects,+        primOpIsCheap, primOpFixity, primOpDocs,++        getPrimOpResultInfo,  isComparisonPrimOp, PrimOpResultInfo(..),++        PrimCall(..)+    ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Builtin.Types.Prim+import GHC.Builtin.Types++import GHC.Cmm.Type+import GHC.Types.Demand+import GHC.Types.Id      ( Id, mkVanillaGlobalWithInfo )+import GHC.Types.Id.Info ( vanillaIdInfo, setCafInfo, CafInfo(NoCafRefs) )+import GHC.Types.Name+import GHC.Builtin.Names ( gHC_PRIMOPWRAPPERS )+import GHC.Core.TyCon    ( TyCon, isPrimTyCon, PrimRep(..) )+import GHC.Core.Type+import GHC.Types.RepType ( typePrimRep1, tyConPrimRep1 )+import GHC.Types.Basic   ( Arity, Fixity(..), FixityDirection(..), Boxity(..),+                           SourceText(..) )+import GHC.Types.SrcLoc  ( wiredInSrcSpan )+import GHC.Types.ForeignCall ( CLabelString )+import GHC.Types.Unique  ( Unique, mkPrimOpIdUnique, mkPrimOpWrapperUnique )+import GHC.Unit          ( Unit )+import GHC.Utils.Outputable+import GHC.Data.FastString++{-+************************************************************************+*                                                                      *+\subsection[PrimOp-datatype]{Datatype for @PrimOp@ (an enumeration)}+*                                                                      *+************************************************************************++These are in \tr{state-interface.verb} order.+-}++-- supplies:+-- data PrimOp = ...+#include "primop-data-decl.hs-incl"++-- supplies+-- primOpTag :: PrimOp -> Int+#include "primop-tag.hs-incl"+primOpTag _ = error "primOpTag: unknown primop"+++instance Eq PrimOp where+    op1 == op2 = primOpTag op1 == primOpTag op2++instance Ord PrimOp where+    op1 <  op2 =  primOpTag op1 < primOpTag op2+    op1 <= op2 =  primOpTag op1 <= primOpTag op2+    op1 >= op2 =  primOpTag op1 >= primOpTag op2+    op1 >  op2 =  primOpTag op1 > primOpTag op2+    op1 `compare` op2 | op1 < op2  = LT+                      | op1 == op2 = EQ+                      | otherwise  = GT++instance Outputable PrimOp where+    ppr op = pprPrimOp op++data PrimOpVecCat = IntVec+                  | WordVec+                  | FloatVec++-- An @Enum@-derived list would be better; meanwhile... (ToDo)++allThePrimOps :: [PrimOp]+allThePrimOps =+#include "primop-list.hs-incl"++tagToEnumKey :: Unique+tagToEnumKey = mkPrimOpIdUnique (primOpTag TagToEnumOp)++{-+************************************************************************+*                                                                      *+\subsection[PrimOp-info]{The essential info about each @PrimOp@}+*                                                                      *+************************************************************************++The @String@ in the @PrimOpInfos@ is the ``base name'' by which the user may+refer to the primitive operation.  The conventional \tr{#}-for-+unboxed ops is added on later.++The reason for the funny characters in the names is so we do not+interfere with the programmer's Haskell name spaces.++We use @PrimKinds@ for the ``type'' information, because they're+(slightly) more convenient to use than @TyCons@.+-}++data PrimOpInfo+  = Dyadic      OccName         -- string :: T -> T -> T+                Type+  | Monadic     OccName         -- string :: T -> T+                Type+  | Compare     OccName         -- string :: T -> T -> Int#+                Type+  | GenPrimOp   OccName         -- string :: \/a1..an . T1 -> .. -> Tk -> T+                [TyVar]+                [Type]+                Type++mkDyadic, mkMonadic, mkCompare :: FastString -> Type -> PrimOpInfo+mkDyadic str  ty = Dyadic  (mkVarOccFS str) ty+mkMonadic str ty = Monadic (mkVarOccFS str) ty+mkCompare str ty = Compare (mkVarOccFS str) ty++mkGenPrimOp :: FastString -> [TyVar] -> [Type] -> Type -> PrimOpInfo+mkGenPrimOp str tvs tys ty = GenPrimOp (mkVarOccFS str) tvs tys ty++{-+************************************************************************+*                                                                      *+\subsubsection{Strictness}+*                                                                      *+************************************************************************++Not all primops are strict!+-}++primOpStrictness :: PrimOp -> Arity -> StrictSig+        -- See Demand.StrictnessInfo for discussion of what the results+        -- The arity should be the arity of the primop; that's why+        -- this function isn't exported.+#include "primop-strictness.hs-incl"++{-+************************************************************************+*                                                                      *+\subsubsection{Fixity}+*                                                                      *+************************************************************************+-}++primOpFixity :: PrimOp -> Maybe Fixity+#include "primop-fixity.hs-incl"++{-+************************************************************************+*                                                                      *+\subsubsection{Docs}+*                                                                      *+************************************************************************++See Note [GHC.Prim Docs]+-}++primOpDocs :: [(String, String)]+#include "primop-docs.hs-incl"++{-+************************************************************************+*                                                                      *+\subsubsection[PrimOp-comparison]{PrimOpInfo basic comparison ops}+*                                                                      *+************************************************************************++@primOpInfo@ gives all essential information (from which everything+else, notably a type, can be constructed) for each @PrimOp@.+-}++primOpInfo :: PrimOp -> PrimOpInfo+#include "primop-primop-info.hs-incl"+primOpInfo _ = error "primOpInfo: unknown primop"++{-+Here are a load of comments from the old primOp info:++A @Word#@ is an unsigned @Int#@.++@decodeFloat#@ is given w/ Integer-stuff (it's similar).++@decodeDouble#@ is given w/ Integer-stuff (it's similar).++Decoding of floating-point numbers is sorta Integer-related.  Encoding+is done with plain ccalls now (see PrelNumExtra.hs).++A @Weak@ Pointer is created by the @mkWeak#@ primitive:++        mkWeak# :: k -> v -> f -> State# RealWorld+                        -> (# State# RealWorld, Weak# v #)++In practice, you'll use the higher-level++        data Weak v = Weak# v+        mkWeak :: k -> v -> IO () -> IO (Weak v)++The following operation dereferences a weak pointer.  The weak pointer+may have been finalized, so the operation returns a result code which+must be inspected before looking at the dereferenced value.++        deRefWeak# :: Weak# v -> State# RealWorld ->+                        (# State# RealWorld, v, Int# #)++Only look at v if the Int# returned is /= 0 !!++The higher-level op is++        deRefWeak :: Weak v -> IO (Maybe v)++Weak pointers can be finalized early by using the finalize# operation:++        finalizeWeak# :: Weak# v -> State# RealWorld ->+                           (# State# RealWorld, Int#, IO () #)++The Int# returned is either++        0 if the weak pointer has already been finalized, or it has no+          finalizer (the third component is then invalid).++        1 if the weak pointer is still alive, with the finalizer returned+          as the third component.++A {\em stable name/pointer} is an index into a table of stable name+entries.  Since the garbage collector is told about stable pointers,+it is safe to pass a stable pointer to external systems such as C+routines.++\begin{verbatim}+makeStablePtr#  :: a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)+freeStablePtr   :: StablePtr# a -> State# RealWorld -> State# RealWorld+deRefStablePtr# :: StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)+eqStablePtr#    :: StablePtr# a -> StablePtr# a -> Int#+\end{verbatim}++It may seem a bit surprising that @makeStablePtr#@ is a @IO@+operation since it doesn't (directly) involve IO operations.  The+reason is that if some optimisation pass decided to duplicate calls to+@makeStablePtr#@ and we only pass one of the stable pointers over, a+massive space leak can result.  Putting it into the IO monad+prevents this.  (Another reason for putting them in a monad is to+ensure correct sequencing wrt the side-effecting @freeStablePtr@+operation.)++An important property of stable pointers is that if you call+makeStablePtr# twice on the same object you get the same stable+pointer back.++Note that we can implement @freeStablePtr#@ using @_ccall_@ (and,+besides, it's not likely to be used from Haskell) so it's not a+primop.++Question: Why @RealWorld@ - won't any instance of @_ST@ do the job? [ADR]++Stable Names+~~~~~~~~~~~~++A stable name is like a stable pointer, but with three important differences:++        (a) You can't deRef one to get back to the original object.+        (b) You can convert one to an Int.+        (c) You don't need to 'freeStableName'++The existence of a stable name doesn't guarantee to keep the object it+points to alive (unlike a stable pointer), hence (a).++Invariants:++        (a) makeStableName always returns the same value for a given+            object (same as stable pointers).++        (b) if two stable names are equal, it implies that the objects+            from which they were created were the same.++        (c) stableNameToInt always returns the same Int for a given+            stable name.+++These primops are pretty weird.++        tagToEnum# :: Int -> a    (result type must be an enumerated type)++The constraints aren't currently checked by the front end, but the+code generator will fall over if they aren't satisfied.++************************************************************************+*                                                                      *+            Which PrimOps are out-of-line+*                                                                      *+************************************************************************++Some PrimOps need to be called out-of-line because they either need to+perform a heap check or they block.+-}++primOpOutOfLine :: PrimOp -> Bool+#include "primop-out-of-line.hs-incl"++{-+************************************************************************+*                                                                      *+            Failure and side effects+*                                                                      *+************************************************************************++Note [Checking versus non-checking primops]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++  In GHC primops break down into two classes:++   a. Checking primops behave, for instance, like division. In this+      case the primop may throw an exception (e.g. division-by-zero)+      and is consequently is marked with the can_fail flag described below.+      The ability to fail comes at the expense of precluding some optimizations.++   b. Non-checking primops behavior, for instance, like addition. While+      addition can overflow it does not produce an exception. So can_fail is+      set to False, and we get more optimisation opportunities.  But we must+      never throw an exception, so we cannot rewrite to a call to error.++  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 [Core let/app invariant] in GHC.Core) which is critical to+  the simplifier's ability to float without fear of changing program meaning.+++Note [PrimOp can_fail and has_side_effects]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Both can_fail and has_side_effects mean that the primop has+some effect that is not captured entirely by its result value.++----------  has_side_effects ---------------------+A primop "has_side_effects" if it has some *write* effect, visible+elsewhere+    - writing to the world (I/O)+    - writing to a mutable data structure (writeIORef)+    - throwing a synchronous Haskell exception++Often such primops have a type like+   State -> input -> (State, output)+so the state token guarantees ordering.  In general we rely *only* on+data dependencies of the state token to enforce write-effect ordering++ * NB1: if you inline unsafePerformIO, you may end up with+   side-effecting ops whose 'state' output is discarded.+   And programmers may do that by hand; see #9390.+   That is why we (conservatively) do not discard write-effecting+   primops even if both their state and result is discarded.++ * NB2: We consider primops, such as raiseIO#, that can raise a+   (Haskell) synchronous exception to "have_side_effects" but not+   "can_fail".  We must be careful about not discarding such things;+   see the paper "A semantics for imprecise exceptions".++ * NB3: *Read* effects (like reading an IORef) don't count here,+   because it doesn't matter if we don't do them, or do them more than+   once.  *Sequencing* is maintained by the data dependency of the state+   token.++----------  can_fail ----------------------------+A primop "can_fail" if it can fail with an *unchecked* exception on+some elements of its input domain. Main examples:+   division (fails on zero denominator)+   array indexing (fails if the index is out of bounds)++An "unchecked exception" is one that is an outright error, (not+turned into a Haskell exception,) such as seg-fault or+divide-by-zero error.  Such can_fail primops are ALWAYS surrounded+with a test that checks for the bad cases, but we need to be+very careful about code motion that might move it out of+the scope of the test.++Note [Transformations affected by can_fail and has_side_effects]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The can_fail and has_side_effects properties have the following effect+on program transformations.  Summary table is followed by details.++            can_fail     has_side_effects+Discard        YES           NO+Float in       YES           YES+Float out      NO            NO+Duplicate      YES           NO++* Discarding.   case (a `op` b) of _ -> rhs  ===>   rhs+  You should not discard a has_side_effects primop; e.g.+     case (writeIntArray# a i v s of (# _, _ #) -> True+  Arguably you should be able to discard this, since the+  returned stat token is not used, but that relies on NEVER+  inlining unsafePerformIO, and programmers sometimes write+  this kind of stuff by hand (#9390).  So we (conservatively)+  never discard a has_side_effects primop.++  However, it's fine to discard a can_fail primop.  For example+     case (indexIntArray# a i) of _ -> True+  We can discard indexIntArray#; it has can_fail, but not+  has_side_effects; see #5658 which was all about this.+  Notice that indexIntArray# is (in a more general handling of+  effects) read effect, but we don't care about that here, and+  treat read effects as *not* has_side_effects.++  Similarly (a `/#` b) can be discarded.  It can seg-fault or+  cause a hardware exception, but not a synchronous Haskell+  exception.++++  Synchronous Haskell exceptions, e.g. from raiseIO#, are treated+  as has_side_effects and hence are not discarded.++* Float in.  You can float a can_fail or has_side_effects primop+  *inwards*, but not inside a lambda (see Duplication below).++* Float out.  You must not float a can_fail primop *outwards* lest+  you escape the dynamic scope of the test.  Example:+      case d ># 0# of+        True  -> case x /# d of r -> r +# 1+        False -> 0+  Here we must not float the case outwards to give+      case x/# d of r ->+      case d ># 0# of+        True  -> r +# 1+        False -> 0++  Nor can you float out a has_side_effects primop.  For example:+       if blah then case writeMutVar# v True s0 of (# s1 #) -> s1+               else s0+  Notice that s0 is mentioned in both branches of the 'if', but+  only one of these two will actually be consumed.  But if we+  float out to+      case writeMutVar# v True s0 of (# s1 #) ->+      if blah then s1 else s0+  the writeMutVar will be performed in both branches, which is+  utterly wrong.++* Duplication.  You cannot duplicate a has_side_effect primop.  You+  might wonder how this can occur given the state token threading, but+  just look at Control.Monad.ST.Lazy.Imp.strictToLazy!  We get+  something like this+        p = case readMutVar# s v of+              (# s', r #) -> (S# s', r)+        s' = case p of (s', r) -> s'+        r  = case p of (s', r) -> r++  (All these bindings are boxed.)  If we inline p at its two call+  sites, we get a catastrophe: because the read is performed once when+  s' is demanded, and once when 'r' is demanded, which may be much+  later.  Utterly wrong.  #3207 is real example of this happening.++  However, it's fine to duplicate a can_fail primop.  That is really+  the only difference between can_fail and has_side_effects.++Note [Implementation: how can_fail/has_side_effects affect transformations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+How do we ensure that that floating/duplication/discarding are done right+in the simplifier?++Two main predicates on primpops test these flags:+  primOpOkForSideEffects <=> not has_side_effects+  primOpOkForSpeculation <=> not (has_side_effects || can_fail)++  * The "no-float-out" thing is achieved by ensuring that we never+    let-bind a can_fail or has_side_effects primop.  The RHS of a+    let-binding (which can float in and out freely) satisfies+    exprOkForSpeculation; this is the let/app invariant.  And+    exprOkForSpeculation is false of can_fail and has_side_effects.++  * So can_fail and has_side_effects primops will appear only as the+    scrutinees of cases, and that's why the FloatIn pass is capable+    of floating case bindings inwards.++  * The no-duplicate thing is done via primOpIsCheap, by making+    has_side_effects things (very very very) not-cheap!+-}++primOpHasSideEffects :: PrimOp -> Bool+#include "primop-has-side-effects.hs-incl"++primOpCanFail :: PrimOp -> Bool+#include "primop-can-fail.hs-incl"++primOpOkForSpeculation :: PrimOp -> Bool+  -- See Note [PrimOp can_fail and has_side_effects]+  -- See comments with GHC.Core.Utils.exprOkForSpeculation+  -- primOpOkForSpeculation => primOpOkForSideEffects+primOpOkForSpeculation op+  =  primOpOkForSideEffects op+  && not (primOpOutOfLine op || primOpCanFail op)+    -- I think the "out of line" test is because out of line things can+    -- be expensive (eg sine, cosine), and so we may not want to speculate them++primOpOkForSideEffects :: PrimOp -> Bool+primOpOkForSideEffects op+  = not (primOpHasSideEffects op)++{-+Note [primOpIsCheap]+~~~~~~~~~~~~~~~~~~~~++@primOpIsCheap@, as used in GHC.Core.Opt.Simplify.Utils.  For now (HACK+WARNING), we just borrow some other predicates for a+what-should-be-good-enough test.  "Cheap" means willing to call it more+than once, and/or push it inside a lambda.  The latter could change the+behaviour of 'seq' for primops that can fail, so we don't treat them as cheap.+-}++primOpIsCheap :: PrimOp -> Bool+-- See Note [PrimOp can_fail and has_side_effects]+primOpIsCheap op = primOpOkForSpeculation op+-- In March 2001, we changed this to+--      primOpIsCheap op = False+-- thereby making *no* primops seem cheap.  But this killed eta+-- expansion on case (x ==# y) of True -> \s -> ...+-- which is bad.  In particular a loop like+--      doLoop n = loop 0+--     where+--         loop i | i == n    = return ()+--                | otherwise = bar i >> loop (i+1)+-- allocated a closure every time round because it doesn't eta expand.+--+-- The problem that originally gave rise to the change was+--      let x = a +# b *# c in x +# x+-- were we don't want to inline x. But primopIsCheap doesn't control+-- that (it's exprIsDupable that does) so the problem doesn't occur+-- even if primOpIsCheap sometimes says 'True'.++{-+************************************************************************+*                                                                      *+               PrimOp code size+*                                                                      *+************************************************************************++primOpCodeSize+~~~~~~~~~~~~~~+Gives an indication of the code size of a primop, for the purposes of+calculating unfolding sizes; see GHC.Core.Unfold.sizeExpr.+-}++primOpCodeSize :: PrimOp -> Int+#include "primop-code-size.hs-incl"++primOpCodeSizeDefault :: Int+primOpCodeSizeDefault = 1+  -- GHC.Core.Unfold.primOpSize already takes into account primOpOutOfLine+  -- and adds some further costs for the args in that case.++primOpCodeSizeForeignCall :: Int+primOpCodeSizeForeignCall = 4++{-+************************************************************************+*                                                                      *+               PrimOp types+*                                                                      *+************************************************************************+-}++primOpType :: PrimOp -> Type  -- you may want to use primOpSig instead+primOpType op+  = case primOpInfo op of+    Dyadic  _occ ty -> dyadic_fun_ty ty+    Monadic _occ ty -> monadic_fun_ty ty+    Compare _occ ty -> compare_fun_ty ty++    GenPrimOp _occ tyvars arg_tys res_ty ->+        mkSpecForAllTys tyvars (mkVisFunTys arg_tys res_ty)++primOpOcc :: PrimOp -> OccName+primOpOcc op = case primOpInfo op of+               Dyadic    occ _     -> occ+               Monadic   occ _     -> occ+               Compare   occ _     -> occ+               GenPrimOp occ _ _ _ -> occ++{- Note [Primop wrappers]+~~~~~~~~~~~~~~~~~~~~~~~~~+Previously hasNoBinding would claim that PrimOpIds didn't have a curried+function definition. This caused quite some trouble as we would be forced to+eta expand unsaturated primop applications very late in the Core pipeline. Not+only would this produce unnecessary thunks, but it would also result in nasty+inconsistencies in CAFfy-ness determinations (see #16846 and+Note [CAFfyness inconsistencies due to late eta expansion] in GHC.Iface.Tidy).++However, it was quite unnecessary for hasNoBinding to claim this; primops in+fact *do* have curried definitions which are found in GHC.PrimopWrappers, which+is auto-generated by utils/genprimops from prelude/primops.txt.pp. These wrappers+are standard Haskell functions mirroring the types of the primops they wrap.+For instance, in the case of plusInt# we would have:++    module GHC.PrimopWrappers where+    import GHC.Prim as P+    plusInt# a b = P.plusInt# a b++We now take advantage of these curried definitions by letting hasNoBinding+claim that PrimOpIds have a curried definition and then rewrite any unsaturated+PrimOpId applications that we find during CoreToStg as applications of the+associated wrapper (e.g. `GHC.Prim.plusInt# 3#` will get rewritten to+`GHC.PrimopWrappers.plusInt# 3#`).` The Id of the wrapper for a primop can be+found using 'PrimOp.primOpWrapperId'.++Nota Bene: GHC.PrimopWrappers is needed *regardless*, because it's+used by GHCi, which does not implement primops direct at all.++-}++-- | Returns the 'Id' of the wrapper associated with the given 'PrimOp'.+-- See Note [Primop wrappers].+primOpWrapperId :: PrimOp -> Id+primOpWrapperId op = mkVanillaGlobalWithInfo name ty info+  where+    info = setCafInfo vanillaIdInfo NoCafRefs+    name = mkExternalName uniq gHC_PRIMOPWRAPPERS (primOpOcc op) wiredInSrcSpan+    uniq = mkPrimOpWrapperUnique (primOpTag op)+    ty   = primOpType op++isComparisonPrimOp :: PrimOp -> Bool+isComparisonPrimOp op = case primOpInfo op of+                          Compare {} -> True+                          _          -> False++-- primOpSig is like primOpType but gives the result split apart:+-- (type variables, argument types, result type)+-- It also gives arity, strictness info++primOpSig :: PrimOp -> ([TyVar], [Type], Type, Arity, StrictSig)+primOpSig op+  = (tyvars, arg_tys, res_ty, arity, primOpStrictness op arity)+  where+    arity = length arg_tys+    (tyvars, arg_tys, res_ty)+      = case (primOpInfo op) of+        Monadic   _occ ty                    -> ([],     [ty],    ty       )+        Dyadic    _occ ty                    -> ([],     [ty,ty], ty       )+        Compare   _occ ty                    -> ([],     [ty,ty], intPrimTy)+        GenPrimOp _occ tyvars arg_tys res_ty -> (tyvars, arg_tys, res_ty   )++data PrimOpResultInfo+  = ReturnsPrim     PrimRep+  | ReturnsAlg      TyCon++-- Some PrimOps need not return a manifest primitive or algebraic value+-- (i.e. they might return a polymorphic value).  These PrimOps *must*+-- be out of line, or the code generator won't work.++getPrimOpResultInfo :: PrimOp -> PrimOpResultInfo+getPrimOpResultInfo op+  = case (primOpInfo op) of+      Dyadic  _ ty                        -> ReturnsPrim (typePrimRep1 ty)+      Monadic _ ty                        -> ReturnsPrim (typePrimRep1 ty)+      Compare _ _                         -> ReturnsPrim (tyConPrimRep1 intPrimTyCon)+      GenPrimOp _ _ _ ty | isPrimTyCon tc -> ReturnsPrim (tyConPrimRep1 tc)+                         | otherwise      -> ReturnsAlg tc+                         where+                           tc = tyConAppTyCon ty+                        -- All primops return a tycon-app result+                        -- The tycon can be an unboxed tuple or sum, though,+                        -- which gives rise to a ReturnAlg++{-+We do not currently make use of whether primops are commutable.++We used to try to move constants to the right hand side for strength+reduction.+-}++{-+commutableOp :: PrimOp -> Bool+#include "primop-commutable.hs-incl"+-}++-- Utils:++dyadic_fun_ty, monadic_fun_ty, compare_fun_ty :: Type -> Type+dyadic_fun_ty  ty = mkVisFunTys [ty, ty] ty+monadic_fun_ty ty = mkVisFunTy  ty ty+compare_fun_ty ty = mkVisFunTys [ty, ty] intPrimTy++-- Output stuff:++pprPrimOp  :: PrimOp -> SDoc+pprPrimOp other_op = pprOccName (primOpOcc other_op)++{-+************************************************************************+*                                                                      *+\subsubsection[PrimCall]{User-imported primitive calls}+*                                                                      *+************************************************************************+-}++data PrimCall = PrimCall CLabelString Unit++instance Outputable PrimCall where+  ppr (PrimCall lbl pkgId)+        = text "__primcall" <+> ppr pkgId <+> ppr lbl
+ compiler/GHC/Builtin/PrimOps.hs-boot view
@@ -0,0 +1,5 @@+module GHC.Builtin.PrimOps where++import GHC.Prelude ()++data PrimOp
+ compiler/GHC/Builtin/Types.hs view
@@ -0,0 +1,1722 @@+{-+(c) The GRASP Project, Glasgow University, 1994-1998++Wired-in knowledge about {\em non-primitive} types+-}++{-# LANGUAGE CPP #-}+{-# LANGUAGE OverloadedStrings #-}++{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++-- | This module is about types that can be defined in Haskell, but which+--   must be wired into the compiler nonetheless.  C.f module GHC.Builtin.Types.Prim+module GHC.Builtin.Types (+        -- * Helper functions defined here+        mkWiredInTyConName, -- This is used in GHC.Builtin.Types.Literals to define the+                            -- built-in functions for evaluation.++        mkWiredInIdName,    -- used in GHC.Types.Id.Make++        -- * All wired in things+        wiredInTyCons, isBuiltInOcc_maybe,++        -- * Bool+        boolTy, boolTyCon, boolTyCon_RDR, boolTyConName,+        trueDataCon,  trueDataConId,  true_RDR,+        falseDataCon, falseDataConId, false_RDR,+        promotedFalseDataCon, promotedTrueDataCon,++        -- * Ordering+        orderingTyCon,+        ordLTDataCon, ordLTDataConId,+        ordEQDataCon, ordEQDataConId,+        ordGTDataCon, ordGTDataConId,+        promotedLTDataCon, promotedEQDataCon, promotedGTDataCon,++        -- * Boxing primitive types+        boxingDataCon_maybe,++        -- * Char+        charTyCon, charDataCon, charTyCon_RDR,+        charTy, stringTy, charTyConName,++        -- * Double+        doubleTyCon, doubleDataCon, doubleTy, doubleTyConName,++        -- * Float+        floatTyCon, floatDataCon, floatTy, floatTyConName,++        -- * Int+        intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName,+        intTy,++        -- * Word+        wordTyCon, wordDataCon, wordTyConName, wordTy,++        -- * Word8+        word8TyCon, word8DataCon, word8TyConName, word8Ty,++        -- * List+        listTyCon, listTyCon_RDR, listTyConName, listTyConKey,+        nilDataCon, nilDataConName, nilDataConKey,+        consDataCon_RDR, consDataCon, consDataConName,+        promotedNilDataCon, promotedConsDataCon,+        mkListTy, mkPromotedListTy,++        -- * Maybe+        maybeTyCon, maybeTyConName,+        nothingDataCon, nothingDataConName, promotedNothingDataCon,+        justDataCon, justDataConName, promotedJustDataCon,++        -- * Tuples+        mkTupleTy, mkTupleTy1, mkBoxedTupleTy, mkTupleStr,+        tupleTyCon, tupleDataCon, tupleTyConName, tupleDataConName,+        promotedTupleDataCon,+        unitTyCon, unitDataCon, unitDataConId, unitTy, unitTyConKey,+        pairTyCon,+        unboxedUnitTyCon, unboxedUnitDataCon,+        unboxedTupleKind, unboxedSumKind,++        -- ** Constraint tuples+        cTupleTyConName, cTupleTyConNames, isCTupleTyConName,+        cTupleTyConNameArity_maybe,+        cTupleDataConName, cTupleDataConNames,++        -- * Any+        anyTyCon, anyTy, anyTypeOfKind,++        -- * Recovery TyCon+        makeRecoveryTyCon,++        -- * Sums+        mkSumTy, sumTyCon, sumDataCon,++        -- * Kinds+        typeNatKindCon, typeNatKind, typeSymbolKindCon, typeSymbolKind,+        isLiftedTypeKindTyConName, liftedTypeKind,+        typeToTypeKind, constraintKind,+        liftedTypeKindTyCon, constraintKindTyCon,  constraintKindTyConName,+        liftedTypeKindTyConName,++        -- * Equality predicates+        heqTyCon, heqTyConName, heqClass, heqDataCon,+        eqTyCon, eqTyConName, eqClass, eqDataCon, eqTyCon_RDR,+        coercibleTyCon, coercibleTyConName, coercibleDataCon, coercibleClass,++        -- * RuntimeRep and friends+        runtimeRepTyCon, vecCountTyCon, vecElemTyCon,++        runtimeRepTy, liftedRepTy, liftedRepDataCon, liftedRepDataConTyCon,++        vecRepDataConTyCon, tupleRepDataConTyCon, sumRepDataConTyCon,++        liftedRepDataConTy, unliftedRepDataConTy,+        intRepDataConTy,+        int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,+        wordRepDataConTy,+        word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,+        addrRepDataConTy,+        floatRepDataConTy, doubleRepDataConTy,++        vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,+        vec64DataConTy,++        int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,+        int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,+        word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,+        doubleElemRepDataConTy+    ) where++#include "HsVersions.h"++import GHC.Prelude++import {-# SOURCE #-} GHC.Types.Id.Make ( mkDataConWorkId, mkDictSelId )++-- friends:+import GHC.Builtin.Names+import GHC.Builtin.Types.Prim+import {-# SOURCE #-} GHC.Builtin.Uniques++-- others:+import GHC.Core.Coercion.Axiom+import GHC.Types.Id+import GHC.Settings.Constants ( mAX_TUPLE_SIZE, mAX_CTUPLE_SIZE, mAX_SUM_SIZE )+import GHC.Unit.Module        ( Module )+import GHC.Core.Type+import GHC.Types.RepType+import GHC.Core.DataCon+import {-# SOURCE #-} GHC.Core.ConLike+import GHC.Core.TyCon+import GHC.Core.Class     ( Class, mkClass )+import GHC.Types.Name.Reader+import GHC.Types.Name as Name+import GHC.Types.Name.Env ( NameEnv, mkNameEnv, lookupNameEnv, lookupNameEnv_NF )+import GHC.Types.Name.Set ( NameSet, mkNameSet, elemNameSet )+import GHC.Types.Basic+import GHC.Types.ForeignCall+import GHC.Types.SrcLoc   ( noSrcSpan )+import GHC.Types.Unique+import Data.Array+import GHC.Data.FastString+import GHC.Utils.Outputable+import GHC.Utils.Misc+import GHC.Data.BooleanFormula ( mkAnd )++import qualified Data.ByteString.Char8 as BS++import Data.List        ( elemIndex )++alpha_tyvar :: [TyVar]+alpha_tyvar = [alphaTyVar]++alpha_ty :: [Type]+alpha_ty = [alphaTy]++{-+Note [Wiring in RuntimeRep]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+The RuntimeRep type (and friends) in GHC.Types has a bunch of constructors,+making it a pain to wire in. To ease the pain somewhat, we use lists of+the different bits, like Uniques, Names, DataCons. These lists must be+kept in sync with each other. The rule is this: use the order as declared+in GHC.Types. All places where such lists exist should contain a reference+to this Note, so a search for this Note's name should find all the lists.++See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType.++************************************************************************+*                                                                      *+\subsection{Wired in type constructors}+*                                                                      *+************************************************************************++If you change which things are wired in, make sure you change their+names in GHC.Builtin.Names, so they use wTcQual, wDataQual, etc+-}++-- This list is used only to define GHC.Builtin.Utils.wiredInThings. That in turn+-- is used to initialise the name environment carried around by the renamer.+-- This means that if we look up the name of a TyCon (or its implicit binders)+-- that occurs in this list that name will be assigned the wired-in key we+-- define here.+--+-- Because of their infinite nature, this list excludes tuples, Any and implicit+-- parameter TyCons (see Note [Built-in syntax and the OrigNameCache]).+--+-- See also Note [Known-key names]+wiredInTyCons :: [TyCon]++wiredInTyCons = [ -- Units are not treated like other tuples, because they+                  -- are defined in GHC.Base, and there's only a few of them. We+                  -- put them in wiredInTyCons so that they will pre-populate+                  -- the name cache, so the parser in isBuiltInOcc_maybe doesn't+                  -- need to look out for them.+                  unitTyCon+                , unboxedUnitTyCon+                , anyTyCon+                , boolTyCon+                , charTyCon+                , doubleTyCon+                , floatTyCon+                , intTyCon+                , wordTyCon+                , word8TyCon+                , listTyCon+                , maybeTyCon+                , heqTyCon+                , eqTyCon+                , coercibleTyCon+                , typeNatKindCon+                , typeSymbolKindCon+                , runtimeRepTyCon+                , vecCountTyCon+                , vecElemTyCon+                , constraintKindTyCon+                , liftedTypeKindTyCon+                ]++mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name+mkWiredInTyConName built_in modu fs unique tycon+  = mkWiredInName modu (mkTcOccFS fs) unique+                  (ATyCon tycon)        -- Relevant TyCon+                  built_in++mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name+mkWiredInDataConName built_in modu fs unique datacon+  = mkWiredInName modu (mkDataOccFS fs) unique+                  (AConLike (RealDataCon datacon))    -- Relevant DataCon+                  built_in++mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name+mkWiredInIdName mod fs uniq id+ = mkWiredInName mod (mkOccNameFS Name.varName fs) uniq (AnId id) UserSyntax++-- See Note [Kind-changing of (~) and Coercible]+-- in libraries/ghc-prim/GHC/Types.hs+eqTyConName, eqDataConName, eqSCSelIdName :: Name+eqTyConName   = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "~")   eqTyConKey   eqTyCon+eqDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "Eq#") eqDataConKey eqDataCon+eqSCSelIdName = mkWiredInIdName gHC_TYPES (fsLit "eq_sel") eqSCSelIdKey eqSCSelId++{- Note [eqTyCon (~) is built-in syntax]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The (~) type operator used in equality constraints (a~b) is considered built-in+syntax. This has a few consequences:++* The user is not allowed to define their own type constructors with this name:++    ghci> class a ~ b+    <interactive>:1:1: error: Illegal binding of built-in syntax: ~++* Writing (a ~ b) does not require enabling -XTypeOperators. It does, however,+  require -XGADTs or -XTypeFamilies.++* The (~) type operator is always in scope. It doesn't need to be be imported,+  and it cannot be hidden.++* We have a bunch of special cases in the compiler to arrange all of the above.++There's no particular reason for (~) to be special, but fixing this would be a+breaking change.+-}+eqTyCon_RDR :: RdrName+eqTyCon_RDR = nameRdrName eqTyConName++-- See Note [Kind-changing of (~) and Coercible]+-- in libraries/ghc-prim/GHC/Types.hs+heqTyConName, heqDataConName, heqSCSelIdName :: Name+heqTyConName   = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "~~")   heqTyConKey      heqTyCon+heqDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "HEq#") heqDataConKey heqDataCon+heqSCSelIdName = mkWiredInIdName gHC_TYPES (fsLit "heq_sel") heqSCSelIdKey heqSCSelId++-- See Note [Kind-changing of (~) and Coercible] in libraries/ghc-prim/GHC/Types.hs+coercibleTyConName, coercibleDataConName, coercibleSCSelIdName :: Name+coercibleTyConName   = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Coercible")  coercibleTyConKey   coercibleTyCon+coercibleDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "MkCoercible") coercibleDataConKey coercibleDataCon+coercibleSCSelIdName = mkWiredInIdName gHC_TYPES (fsLit "coercible_sel") coercibleSCSelIdKey coercibleSCSelId++charTyConName, charDataConName, intTyConName, intDataConName :: Name+charTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Char") charTyConKey charTyCon+charDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "C#") charDataConKey charDataCon+intTyConName      = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Int") intTyConKey   intTyCon+intDataConName    = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "I#") intDataConKey  intDataCon++boolTyConName, falseDataConName, trueDataConName :: Name+boolTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Bool") boolTyConKey boolTyCon+falseDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "False") falseDataConKey falseDataCon+trueDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "True")  trueDataConKey  trueDataCon++listTyConName, nilDataConName, consDataConName :: Name+listTyConName     = mkWiredInTyConName   BuiltInSyntax gHC_TYPES (fsLit "[]") listTyConKey listTyCon+nilDataConName    = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit "[]") nilDataConKey nilDataCon+consDataConName   = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit ":") consDataConKey consDataCon++maybeTyConName, nothingDataConName, justDataConName :: Name+maybeTyConName     = mkWiredInTyConName   UserSyntax gHC_MAYBE (fsLit "Maybe")+                                          maybeTyConKey maybeTyCon+nothingDataConName = mkWiredInDataConName UserSyntax gHC_MAYBE (fsLit "Nothing")+                                          nothingDataConKey nothingDataCon+justDataConName    = mkWiredInDataConName UserSyntax gHC_MAYBE (fsLit "Just")+                                          justDataConKey justDataCon++wordTyConName, wordDataConName, word8TyConName, word8DataConName :: Name+wordTyConName      = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Word")   wordTyConKey     wordTyCon+wordDataConName    = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "W#")     wordDataConKey   wordDataCon+word8TyConName     = mkWiredInTyConName   UserSyntax gHC_WORD  (fsLit "Word8")  word8TyConKey    word8TyCon+word8DataConName   = mkWiredInDataConName UserSyntax gHC_WORD  (fsLit "W8#")    word8DataConKey  word8DataCon++floatTyConName, floatDataConName, doubleTyConName, doubleDataConName :: Name+floatTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Float")  floatTyConKey    floatTyCon+floatDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "F#")     floatDataConKey  floatDataCon+doubleTyConName    = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Double") doubleTyConKey   doubleTyCon+doubleDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "D#")     doubleDataConKey doubleDataCon++-- Any++{-+Note [Any types]+~~~~~~~~~~~~~~~~+The type constructor Any,++    type family Any :: k where { }++It has these properties:++  * Note that 'Any' is kind polymorphic since in some program we may+    need to use Any to fill in a type variable of some kind other than *+    (see #959 for examples).  Its kind is thus `forall k. k``.++  * It is defined in module GHC.Types, and exported so that it is+    available to users.  For this reason it's treated like any other+    wired-in type:+      - has a fixed unique, anyTyConKey,+      - lives in the global name cache++  * It is a *closed* type family, with no instances.  This means that+    if   ty :: '(k1, k2)  we add a given coercion+             g :: ty ~ (Fst ty, Snd ty)+    If Any was a *data* type, then we'd get inconsistency because 'ty'+    could be (Any '(k1,k2)) and then we'd have an equality with Any on+    one side and '(,) on the other. See also #9097 and #9636.++  * When instantiated at a lifted type it is inhabited by at least one value,+    namely bottom++  * You can safely coerce any /lifted/ type to Any, and back with unsafeCoerce.++  * It does not claim to be a *data* type, and that's important for+    the code generator, because the code gen may *enter* a data value+    but never enters a function value.++  * It is wired-in so we can easily refer to it where we don't have a name+    environment (e.g. see Rules.matchRule for one example)++  * If (Any k) is the type of a value, it must be a /lifted/ value. So+    if we have (Any @(TYPE rr)) then rr must be 'LiftedRep.  See+    Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim.  This is a convenient+    invariant, and makes isUnliftedTyCon well-defined; otherwise what+    would (isUnliftedTyCon Any) be?++It's used to instantiate un-constrained type variables after type checking. For+example, 'length' has type++  length :: forall a. [a] -> Int++and the list datacon for the empty list has type++  [] :: forall a. [a]++In order to compose these two terms as @length []@ a type+application is required, but there is no constraint on the+choice.  In this situation GHC uses 'Any',++> length (Any *) ([] (Any *))++Above, we print kinds explicitly, as if with --fprint-explicit-kinds.++The Any tycon used to be quite magic, but we have since been able to+implement it merely with an empty kind polymorphic type family. See #10886 for a+bit of history.+-}+++anyTyConName :: Name+anyTyConName =+    mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Any") anyTyConKey anyTyCon++anyTyCon :: TyCon+anyTyCon = mkFamilyTyCon anyTyConName binders res_kind Nothing+                         (ClosedSynFamilyTyCon Nothing)+                         Nothing+                         NotInjective+  where+    binders@[kv] = mkTemplateKindTyConBinders [liftedTypeKind]+    res_kind = mkTyVarTy (binderVar kv)++anyTy :: Type+anyTy = mkTyConTy anyTyCon++anyTypeOfKind :: Kind -> Type+anyTypeOfKind kind = mkTyConApp anyTyCon [kind]++-- | Make a fake, recovery 'TyCon' from an existing one.+-- Used when recovering from errors in type declarations+makeRecoveryTyCon :: TyCon -> TyCon+makeRecoveryTyCon tc+  = mkTcTyCon (tyConName tc)+              bndrs res_kind+              noTcTyConScopedTyVars+              True             -- Fully generalised+              flavour          -- Keep old flavour+  where+    flavour = tyConFlavour tc+    [kv] = mkTemplateKindVars [liftedTypeKind]+    (bndrs, res_kind)+       = case flavour of+           PromotedDataConFlavour -> ([mkNamedTyConBinder Inferred kv], mkTyVarTy kv)+           _ -> (tyConBinders tc, tyConResKind tc)+        -- For data types we have already validated their kind, so it+        -- makes sense to keep it. For promoted data constructors we haven't,+        -- so we recover with kind (forall k. k).  Otherwise consider+        --     data T a where { MkT :: Show a => T a }+        -- If T is for some reason invalid, we don't want to fall over+        -- at (promoted) use-sites of MkT.++-- Kinds+typeNatKindConName, typeSymbolKindConName :: Name+typeNatKindConName    = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Nat")    typeNatKindConNameKey    typeNatKindCon+typeSymbolKindConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Symbol") typeSymbolKindConNameKey typeSymbolKindCon++constraintKindTyConName :: Name+constraintKindTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Constraint") constraintKindTyConKey   constraintKindTyCon++liftedTypeKindTyConName :: Name+liftedTypeKindTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Type") liftedTypeKindTyConKey liftedTypeKindTyCon++runtimeRepTyConName, vecRepDataConName, tupleRepDataConName, sumRepDataConName :: Name+runtimeRepTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "RuntimeRep") runtimeRepTyConKey runtimeRepTyCon+vecRepDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "VecRep") vecRepDataConKey vecRepDataCon+tupleRepDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "TupleRep") tupleRepDataConKey tupleRepDataCon+sumRepDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "SumRep") sumRepDataConKey sumRepDataCon++-- See Note [Wiring in RuntimeRep]+runtimeRepSimpleDataConNames :: [Name]+runtimeRepSimpleDataConNames+  = zipWith3Lazy mk_special_dc_name+      [ fsLit "LiftedRep", fsLit "UnliftedRep"+      , fsLit "IntRep"+      , fsLit "Int8Rep", fsLit "Int16Rep", fsLit "Int32Rep", fsLit "Int64Rep"+      , fsLit "WordRep"+      , fsLit "Word8Rep", fsLit "Word16Rep", fsLit "Word32Rep", fsLit "Word64Rep"+      , fsLit "AddrRep"+      , fsLit "FloatRep", fsLit "DoubleRep"+      ]+      runtimeRepSimpleDataConKeys+      runtimeRepSimpleDataCons++vecCountTyConName :: Name+vecCountTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "VecCount") vecCountTyConKey vecCountTyCon++-- See Note [Wiring in RuntimeRep]+vecCountDataConNames :: [Name]+vecCountDataConNames = zipWith3Lazy mk_special_dc_name+                         [ fsLit "Vec2", fsLit "Vec4", fsLit "Vec8"+                         , fsLit "Vec16", fsLit "Vec32", fsLit "Vec64" ]+                         vecCountDataConKeys+                         vecCountDataCons++vecElemTyConName :: Name+vecElemTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "VecElem") vecElemTyConKey vecElemTyCon++-- See Note [Wiring in RuntimeRep]+vecElemDataConNames :: [Name]+vecElemDataConNames = zipWith3Lazy mk_special_dc_name+                        [ fsLit "Int8ElemRep", fsLit "Int16ElemRep", fsLit "Int32ElemRep"+                        , fsLit "Int64ElemRep", fsLit "Word8ElemRep", fsLit "Word16ElemRep"+                        , fsLit "Word32ElemRep", fsLit "Word64ElemRep"+                        , fsLit "FloatElemRep", fsLit "DoubleElemRep" ]+                        vecElemDataConKeys+                        vecElemDataCons++mk_special_dc_name :: FastString -> Unique -> DataCon -> Name+mk_special_dc_name fs u dc = mkWiredInDataConName UserSyntax gHC_TYPES fs u dc++boolTyCon_RDR, false_RDR, true_RDR, intTyCon_RDR, charTyCon_RDR,+    intDataCon_RDR, listTyCon_RDR, consDataCon_RDR :: RdrName+boolTyCon_RDR   = nameRdrName boolTyConName+false_RDR       = nameRdrName falseDataConName+true_RDR        = nameRdrName trueDataConName+intTyCon_RDR    = nameRdrName intTyConName+charTyCon_RDR   = nameRdrName charTyConName+intDataCon_RDR  = nameRdrName intDataConName+listTyCon_RDR   = nameRdrName listTyConName+consDataCon_RDR = nameRdrName consDataConName++{-+************************************************************************+*                                                                      *+\subsection{mkWiredInTyCon}+*                                                                      *+************************************************************************+-}++-- This function assumes that the types it creates have all parameters at+-- Representational role, and that there is no kind polymorphism.+pcTyCon :: Name -> Maybe CType -> [TyVar] -> [DataCon] -> TyCon+pcTyCon name cType tyvars cons+  = mkAlgTyCon name+                (mkAnonTyConBinders VisArg tyvars)+                liftedTypeKind+                (map (const Representational) tyvars)+                cType+                []              -- No stupid theta+                (mkDataTyConRhs cons)+                (VanillaAlgTyCon (mkPrelTyConRepName name))+                False           -- Not in GADT syntax++pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon+pcDataCon n univs = pcDataConWithFixity False n univs+                      []    -- no ex_tvs+                      univs -- the univs are precisely the user-written tyvars++pcDataConWithFixity :: Bool      -- ^ declared infix?+                    -> Name      -- ^ datacon name+                    -> [TyVar]   -- ^ univ tyvars+                    -> [TyCoVar] -- ^ ex tycovars+                    -> [TyCoVar] -- ^ user-written tycovars+                    -> [Type]    -- ^ args+                    -> TyCon+                    -> DataCon+pcDataConWithFixity infx n = pcDataConWithFixity' infx n (dataConWorkerUnique (nameUnique n))+                                                  NoRRI+-- The Name's unique is the first of two free uniques;+-- the first is used for the datacon itself,+-- the second is used for the "worker name"+--+-- To support this the mkPreludeDataConUnique function "allocates"+-- one DataCon unique per pair of Ints.++pcDataConWithFixity' :: Bool -> Name -> Unique -> RuntimeRepInfo+                     -> [TyVar] -> [TyCoVar] -> [TyCoVar]+                     -> [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+  = data_con+  where+    tag_map = mkTyConTagMap tycon+    -- This constructs the constructor Name to ConTag map once per+    -- constructor, which is quadratic. It's OK here, because it's+    -- only called for wired in data types that don't have a lot of+    -- constructors. It's also likely that GHC will lift tag_map, since+    -- we call pcDataConWithFixity' with static TyCons in the same module.+    -- See Note [Constructor tag allocation] and #14657+    data_con = mkDataCon dc_name declared_infix prom_info+                (map (const no_bang) arg_tys)+                []      -- No labelled fields+                tyvars ex_tyvars+                (mkTyCoVarBinders Specified user_tyvars)+                []      -- No equality spec+                []      -- No theta+                arg_tys (mkTyConApp tycon (mkTyVarTys tyvars))+                rri+                tycon+                (lookupNameEnv_NF tag_map dc_name)+                []      -- No stupid theta+                (mkDataConWorkId wrk_name data_con)+                NoDataConRep    -- Wired-in types are too simple to need wrappers++    no_bang = HsSrcBang NoSourceText NoSrcUnpack NoSrcStrict++    wrk_name = mkDataConWorkerName data_con wrk_key++    prom_info = mkPrelTyConRepName dc_name++mkDataConWorkerName :: DataCon -> Unique -> Name+mkDataConWorkerName data_con wrk_key =+    mkWiredInName modu wrk_occ wrk_key+                  (AnId (dataConWorkId data_con)) UserSyntax+  where+    modu     = ASSERT( isExternalName dc_name )+               nameModule dc_name+    dc_name = dataConName data_con+    dc_occ  = nameOccName dc_name+    wrk_occ = mkDataConWorkerOcc dc_occ++-- used for RuntimeRep and friends+pcSpecialDataCon :: Name -> [Type] -> TyCon -> RuntimeRepInfo -> DataCon+pcSpecialDataCon dc_name arg_tys tycon rri+  = pcDataConWithFixity' False dc_name (dataConWorkerUnique (nameUnique dc_name)) rri+                         [] [] [] arg_tys tycon++{-+************************************************************************+*                                                                      *+      Kinds+*                                                                      *+************************************************************************+-}++typeNatKindCon, typeSymbolKindCon :: TyCon+-- data Nat+-- data Symbol+typeNatKindCon    = pcTyCon typeNatKindConName    Nothing [] []+typeSymbolKindCon = pcTyCon typeSymbolKindConName Nothing [] []++typeNatKind, typeSymbolKind :: Kind+typeNatKind    = mkTyConTy typeNatKindCon+typeSymbolKind = mkTyConTy typeSymbolKindCon++constraintKindTyCon :: TyCon+-- 'TyCon.isConstraintKindCon' assumes that this is an AlgTyCon!+constraintKindTyCon = pcTyCon constraintKindTyConName Nothing [] []++liftedTypeKind, typeToTypeKind, constraintKind :: Kind+liftedTypeKind   = tYPE liftedRepTy+typeToTypeKind   = liftedTypeKind `mkVisFunTy` liftedTypeKind+constraintKind   = mkTyConApp constraintKindTyCon []++{-+************************************************************************+*                                                                      *+                Stuff for dealing with tuples+*                                                                      *+************************************************************************++Note [How tuples work]  See also Note [Known-key names] in GHC.Builtin.Names+~~~~~~~~~~~~~~~~~~~~~~+* There are three families of tuple TyCons and corresponding+  DataCons, expressed by the type BasicTypes.TupleSort:+    data TupleSort = BoxedTuple | UnboxedTuple | ConstraintTuple++* All three families are AlgTyCons, whose AlgTyConRhs is TupleTyCon++* BoxedTuples+    - A wired-in type+    - Data type declarations in GHC.Tuple+    - The data constructors really have an info table++* UnboxedTuples+    - A wired-in type+    - Have a pretend DataCon, defined in GHC.Prim,+      but no actual declaration and no info table++* ConstraintTuples+    - Are known-key rather than wired-in. Reason: it's awkward to+      have all the superclass selectors wired-in.+    - Declared as classes in GHC.Classes, e.g.+         class (c1,c2) => (c1,c2)+    - Given constraints: the superclasses automatically become available+    - Wanted constraints: there is a built-in instance+         instance (c1,c2) => (c1,c2)+      See GHC.Tc.Solver.Interact.matchCTuple+    - Currently just go up to 62; beyond that+      you have to use manual nesting+    - Their OccNames look like (%,,,%), so they can easily be+      distinguished from term tuples.  But (following Haskell) we+      pretty-print saturated constraint tuples with round parens;+      see BasicTypes.tupleParens.++* In quite a lot of places things are restricted just to+  BoxedTuple/UnboxedTuple, and then we used BasicTypes.Boxity to distinguish+  E.g. tupleTyCon has a Boxity argument++* When looking up an OccName in the original-name cache+  (GHC.Iface.Env.lookupOrigNameCache), we spot the tuple OccName to make sure+  we get the right wired-in name.  This guy can't tell the difference+  between BoxedTuple and ConstraintTuple (same OccName!), so tuples+  are not serialised into interface files using OccNames at all.++* Serialization to interface files works via the usual mechanism for known-key+  things: instead of serializing the OccName we just serialize the key. During+  deserialization we lookup the Name associated with the unique with the logic+  in GHC.Builtin.Uniques. See Note [Symbol table representation of names] for details.++Note [One-tuples]+~~~~~~~~~~~~~~~~~+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 GHC.HsToCore.Utils.mkSelectorBinds, when+   there is just one binder+Basically it keeps everything uniform.++However the /naming/ of the type/data constructors for one-tuples is a+bit odd:+  3-tuples:  (,,)   (,,)#+  2-tuples:  (,)    (,)#+  1-tuples:  ??+  0-tuples:  ()     ()#++Zero-tuples have used up the logical name. So we use 'Unit' and 'Unit#'+for one-tuples.  So in ghc-prim:GHC.Tuple we see the declarations:+  data ()     = ()+  data Unit a = Unit a+  data (a,b)  = (a,b)++There is no way to write a boxed one-tuple in Haskell using tuple syntax.+They can, however, be written using other methods:++1. They can be written directly by importing them from GHC.Tuple.+2. They can be generated by way of Template Haskell or in `deriving` code.++There is nothing special about one-tuples in Core; in particular, they have no+custom pretty-printing, just using `Unit`.++Note that there is *not* a unary constraint tuple, unlike for other forms of+tuples. See [Ignore unary constraint tuples] in GHC.Tc.Gen.HsType for more+details.++See also Note [Flattening one-tuples] in GHC.Core.Make and+Note [Don't flatten tuples from HsSyn] in GHC.Core.Make.++-----+-- Wrinkle: Make boxed one-tuple names have known keys+-----++We make boxed one-tuple names have known keys so that `data Unit a = Unit a`,+defined in GHC.Tuple, will be used when one-tuples are spliced in through+Template Haskell. This program (from #18097) crucially relies on this:++  case $( tupE [ [| "ok" |] ] ) of Unit x -> putStrLn x++Unless Unit has a known key, the type of `$( tupE [ [| "ok" |] ] )` (an+ExplicitTuple of length 1) will not match the type of Unit (an ordinary+data constructor used in a pattern). Making Unit known-key allows GHC to make+this connection.++Unlike Unit, every other tuple is /not/ known-key+(see Note [Infinite families of known-key names] in GHC.Builtin.Names). The+main reason for this exception is that other tuples are written with special+syntax, and as a result, they are renamed using a special `isBuiltInOcc_maybe`+function (see Note [Built-in syntax and the OrigNameCache] in GHC.Types.Name.Cache).+In contrast, Unit is just an ordinary data type with no special syntax, so it+doesn't really make sense to handle it in `isBuiltInOcc_maybe`. Making Unit+known-key is the next-best way to teach the internals of the compiler about it.+-}++-- | Built-in syntax isn't "in scope" so these OccNames map to wired-in Names+-- with BuiltInSyntax. However, this should only be necessary while resolving+-- names produced by Template Haskell splices since we take care to encode+-- built-in syntax names specially in interface files. See+-- Note [Symbol table representation of names].+--+-- Moreover, there is no need to include names of things that the user can't+-- write (e.g. type representation bindings like $tc(,,,)).+isBuiltInOcc_maybe :: OccName -> Maybe Name+isBuiltInOcc_maybe occ =+    case name of+      "[]" -> Just $ choose_ns listTyConName nilDataConName+      ":"    -> Just consDataConName++      -- equality tycon+      "~"    -> Just eqTyConName++      -- function tycon+      "->"   -> Just funTyConName++      -- boxed tuple data/tycon+      -- We deliberately exclude Unit (the boxed 1-tuple).+      -- See Note [One-tuples] (Wrinkle: Make boxed one-tuple names have known keys)+      "()"    -> Just $ tup_name Boxed 0+      _ | Just rest <- "(" `BS.stripPrefix` name+        , (commas, rest') <- BS.span (==',') rest+        , ")" <- rest'+             -> Just $ tup_name Boxed (1+BS.length commas)++      -- unboxed tuple data/tycon+      "(##)"  -> Just $ tup_name Unboxed 0+      "Unit#" -> Just $ tup_name Unboxed 1+      _ | Just rest <- "(#" `BS.stripPrefix` name+        , (commas, rest') <- BS.span (==',') rest+        , "#)" <- rest'+             -> Just $ tup_name Unboxed (1+BS.length commas)++      -- unboxed sum tycon+      _ | Just rest <- "(#" `BS.stripPrefix` name+        , (pipes, rest') <- BS.span (=='|') rest+        , "#)" <- rest'+             -> Just $ tyConName $ sumTyCon (1+BS.length pipes)++      -- unboxed sum datacon+      _ | Just rest <- "(#" `BS.stripPrefix` name+        , (pipes1, rest') <- BS.span (=='|') rest+        , Just rest'' <- "_" `BS.stripPrefix` rest'+        , (pipes2, rest''') <- BS.span (=='|') rest''+        , "#)" <- rest'''+             -> let arity = BS.length pipes1 + BS.length pipes2 + 1+                    alt = BS.length pipes1 + 1+                in Just $ dataConName $ sumDataCon alt arity+      _ -> Nothing+  where+    name = bytesFS $ occNameFS occ++    choose_ns :: Name -> Name -> Name+    choose_ns tc dc+      | isTcClsNameSpace ns   = tc+      | isDataConNameSpace ns = dc+      | otherwise             = pprPanic "tup_name" (ppr occ)+      where ns = occNameSpace occ++    tup_name boxity arity+      = choose_ns (getName (tupleTyCon   boxity arity))+                  (getName (tupleDataCon boxity arity))++mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName+-- No need to cache these, the caching is done in mk_tuple+mkTupleOcc ns Boxed   ar = mkOccName ns (mkBoxedTupleStr   ar)+mkTupleOcc ns Unboxed ar = mkOccName ns (mkUnboxedTupleStr ar)++mkCTupleOcc :: NameSpace -> Arity -> OccName+mkCTupleOcc ns ar = mkOccName ns (mkConstraintTupleStr ar)++mkTupleStr :: Boxity -> Arity -> String+mkTupleStr Boxed   = mkBoxedTupleStr+mkTupleStr Unboxed = mkUnboxedTupleStr++mkBoxedTupleStr :: Arity -> String+mkBoxedTupleStr 0  = "()"+mkBoxedTupleStr 1  = "Unit"   -- See Note [One-tuples]+mkBoxedTupleStr ar = '(' : commas ar ++ ")"++mkUnboxedTupleStr :: Arity -> String+mkUnboxedTupleStr 0  = "(##)"+mkUnboxedTupleStr 1  = "Unit#"  -- See Note [One-tuples]+mkUnboxedTupleStr ar = "(#" ++ commas ar ++ "#)"++mkConstraintTupleStr :: Arity -> String+mkConstraintTupleStr 0  = "(%%)"+mkConstraintTupleStr 1  = "Unit%"   -- See Note [One-tuples]+mkConstraintTupleStr ar = "(%" ++ commas ar ++ "%)"++commas :: Arity -> String+commas ar = take (ar-1) (repeat ',')++cTupleTyConName :: Arity -> Name+cTupleTyConName arity+  = mkExternalName (mkCTupleTyConUnique arity) gHC_CLASSES+                   (mkCTupleOcc tcName arity) noSrcSpan++cTupleTyConNames :: [Name]+cTupleTyConNames = map cTupleTyConName (0 : [2..mAX_CTUPLE_SIZE])++cTupleTyConNameSet :: NameSet+cTupleTyConNameSet = mkNameSet cTupleTyConNames++isCTupleTyConName :: Name -> Bool+-- Use Type.isCTupleClass where possible+isCTupleTyConName n+ = ASSERT2( isExternalName n, ppr n )+   nameModule n == gHC_CLASSES+   && n `elemNameSet` cTupleTyConNameSet++-- | If the given name is that of a constraint tuple, return its arity.+-- Note that this is inefficient.+cTupleTyConNameArity_maybe :: Name -> Maybe Arity+cTupleTyConNameArity_maybe n+  | not (isCTupleTyConName n) = Nothing+  | otherwise = fmap adjustArity (n `elemIndex` cTupleTyConNames)+  where+    -- Since `cTupleTyConNames` jumps straight from the `0` to the `2`+    -- case, we have to adjust accordingly our calculated arity.+    adjustArity a = if a > 0 then a + 1 else a++cTupleDataConName :: Arity -> Name+cTupleDataConName arity+  = mkExternalName (mkCTupleDataConUnique arity) gHC_CLASSES+                   (mkCTupleOcc dataName arity) noSrcSpan++cTupleDataConNames :: [Name]+cTupleDataConNames = map cTupleDataConName (0 : [2..mAX_CTUPLE_SIZE])++tupleTyCon :: Boxity -> Arity -> TyCon+tupleTyCon sort i | i > mAX_TUPLE_SIZE = fst (mk_tuple sort i)  -- Build one specially+tupleTyCon Boxed   i = fst (boxedTupleArr   ! i)+tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)++tupleTyConName :: TupleSort -> Arity -> Name+tupleTyConName ConstraintTuple a = cTupleTyConName a+tupleTyConName BoxedTuple      a = tyConName (tupleTyCon Boxed a)+tupleTyConName UnboxedTuple    a = tyConName (tupleTyCon Unboxed a)++promotedTupleDataCon :: Boxity -> Arity -> TyCon+promotedTupleDataCon boxity i = promoteDataCon (tupleDataCon boxity i)++tupleDataCon :: Boxity -> Arity -> DataCon+tupleDataCon sort i | i > mAX_TUPLE_SIZE = snd (mk_tuple sort i)    -- Build one specially+tupleDataCon Boxed   i = snd (boxedTupleArr   ! i)+tupleDataCon Unboxed i = snd (unboxedTupleArr ! i)++tupleDataConName :: Boxity -> Arity -> Name+tupleDataConName sort i = dataConName (tupleDataCon sort i)++boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)+boxedTupleArr   = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed   i | i <- [0..mAX_TUPLE_SIZE]]+unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]++-- | Given the TupleRep/SumRep tycon and list of RuntimeReps of the unboxed+-- tuple/sum arguments, produces the return kind of an unboxed tuple/sum type+-- constructor. @unboxedTupleSumKind [IntRep, LiftedRep] --> TYPE (TupleRep/SumRep+-- [IntRep, LiftedRep])@+unboxedTupleSumKind :: TyCon -> [Type] -> Kind+unboxedTupleSumKind tc rr_tys+  = tYPE (mkTyConApp tc [mkPromotedListTy runtimeRepTy rr_tys])++-- | Specialization of 'unboxedTupleSumKind' for tuples+unboxedTupleKind :: [Type] -> Kind+unboxedTupleKind = unboxedTupleSumKind tupleRepDataConTyCon++mk_tuple :: Boxity -> Int -> (TyCon,DataCon)+mk_tuple Boxed arity = (tycon, tuple_con)+  where+    tycon = mkTupleTyCon tc_name tc_binders tc_res_kind tc_arity tuple_con+                         BoxedTuple flavour++    tc_binders  = mkTemplateAnonTyConBinders (replicate arity liftedTypeKind)+    tc_res_kind = liftedTypeKind+    tc_arity    = arity+    flavour     = VanillaAlgTyCon (mkPrelTyConRepName tc_name)++    dc_tvs     = binderVars tc_binders+    dc_arg_tys = mkTyVarTys dc_tvs+    tuple_con  = pcDataCon dc_name dc_tvs dc_arg_tys tycon++    boxity  = Boxed+    modu    = gHC_TUPLE+    tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq+                         (ATyCon tycon) BuiltInSyntax+    dc_name = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq+                            (AConLike (RealDataCon tuple_con)) BuiltInSyntax+    tc_uniq = mkTupleTyConUnique   boxity arity+    dc_uniq = mkTupleDataConUnique boxity arity++mk_tuple Unboxed arity = (tycon, tuple_con)+  where+    tycon = mkTupleTyCon tc_name tc_binders tc_res_kind tc_arity tuple_con+                         UnboxedTuple flavour++    -- See Note [Unboxed tuple RuntimeRep vars] in GHC.Core.TyCon+    -- Kind:  forall (k1:RuntimeRep) (k2:RuntimeRep). TYPE k1 -> TYPE k2 -> #+    tc_binders = mkTemplateTyConBinders (replicate arity runtimeRepTy)+                                        (\ks -> map tYPE ks)++    tc_res_kind = unboxedTupleKind rr_tys++    tc_arity    = arity * 2+    flavour     = UnboxedAlgTyCon $ Just (mkPrelTyConRepName tc_name)++    dc_tvs               = binderVars tc_binders+    (rr_tys, dc_arg_tys) = splitAt arity (mkTyVarTys dc_tvs)+    tuple_con            = pcDataCon dc_name dc_tvs dc_arg_tys tycon++    boxity  = Unboxed+    modu    = gHC_PRIM+    tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq+                         (ATyCon tycon) BuiltInSyntax+    dc_name = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq+                            (AConLike (RealDataCon tuple_con)) BuiltInSyntax+    tc_uniq = mkTupleTyConUnique   boxity arity+    dc_uniq = mkTupleDataConUnique boxity arity++unitTyCon :: TyCon+unitTyCon = tupleTyCon Boxed 0++unitTyConKey :: Unique+unitTyConKey = getUnique unitTyCon++unitDataCon :: DataCon+unitDataCon   = head (tyConDataCons unitTyCon)++unitDataConId :: Id+unitDataConId = dataConWorkId unitDataCon++pairTyCon :: TyCon+pairTyCon = tupleTyCon Boxed 2++unboxedUnitTyCon :: TyCon+unboxedUnitTyCon = tupleTyCon Unboxed 0++unboxedUnitDataCon :: DataCon+unboxedUnitDataCon = tupleDataCon   Unboxed 0+++{- *********************************************************************+*                                                                      *+      Unboxed sums+*                                                                      *+********************************************************************* -}++-- | OccName for n-ary unboxed sum type constructor.+mkSumTyConOcc :: Arity -> OccName+mkSumTyConOcc n = mkOccName tcName str+  where+    -- No need to cache these, the caching is done in mk_sum+    str = '(' : '#' : bars ++ "#)"+    bars = replicate (n-1) '|'++-- | OccName for i-th alternative of n-ary unboxed sum data constructor.+mkSumDataConOcc :: ConTag -> Arity -> OccName+mkSumDataConOcc alt n = mkOccName dataName str+  where+    -- No need to cache these, the caching is done in mk_sum+    str = '(' : '#' : bars alt ++ '_' : bars (n - alt - 1) ++ "#)"+    bars i = replicate i '|'++-- | Type constructor for n-ary unboxed sum.+sumTyCon :: Arity -> TyCon+sumTyCon arity+  | arity > mAX_SUM_SIZE+  = fst (mk_sum arity)  -- Build one specially++  | arity < 2+  = panic ("sumTyCon: Arity starts from 2. (arity: " ++ show arity ++ ")")++  | otherwise+  = fst (unboxedSumArr ! arity)++-- | Data constructor for i-th alternative of a n-ary unboxed sum.+sumDataCon :: ConTag -- Alternative+           -> Arity  -- Arity+           -> DataCon+sumDataCon alt arity+  | alt > arity+  = panic ("sumDataCon: index out of bounds: alt: "+           ++ show alt ++ " > arity " ++ show arity)++  | alt <= 0+  = panic ("sumDataCon: Alts start from 1. (alt: " ++ show alt+           ++ ", arity: " ++ show arity ++ ")")++  | arity < 2+  = panic ("sumDataCon: Arity starts from 2. (alt: " ++ show alt+           ++ ", arity: " ++ show arity ++ ")")++  | arity > mAX_SUM_SIZE+  = snd (mk_sum arity) ! (alt - 1)  -- Build one specially++  | otherwise+  = snd (unboxedSumArr ! arity) ! (alt - 1)++-- | Cached type and data constructors for sums. The outer array is+-- indexed by the arity of the sum and the inner array is indexed by+-- the alternative.+unboxedSumArr :: Array Int (TyCon, Array Int DataCon)+unboxedSumArr = listArray (2,mAX_SUM_SIZE) [mk_sum i | i <- [2..mAX_SUM_SIZE]]++-- | Specialization of 'unboxedTupleSumKind' for sums+unboxedSumKind :: [Type] -> Kind+unboxedSumKind = unboxedTupleSumKind sumRepDataConTyCon++-- | Create type constructor and data constructors for n-ary unboxed sum.+mk_sum :: Arity -> (TyCon, Array ConTagZ DataCon)+mk_sum arity = (tycon, sum_cons)+  where+    tycon   = mkSumTyCon tc_name tc_binders tc_res_kind (arity * 2) tyvars (elems sum_cons)+                         (UnboxedAlgTyCon rep_name)++    -- Unboxed sums are currently not Typeable due to efficiency concerns. See #13276.+    rep_name = Nothing -- Just $ mkPrelTyConRepName tc_name++    tc_binders = mkTemplateTyConBinders (replicate arity runtimeRepTy)+                                        (\ks -> map tYPE ks)++    tyvars = binderVars tc_binders++    tc_res_kind = unboxedSumKind rr_tys++    (rr_tys, tyvar_tys) = splitAt arity (mkTyVarTys tyvars)++    tc_name = mkWiredInName gHC_PRIM (mkSumTyConOcc arity) tc_uniq+                            (ATyCon tycon) BuiltInSyntax++    sum_cons = listArray (0,arity-1) [sum_con i | i <- [0..arity-1]]+    sum_con i = let dc = pcDataCon dc_name+                                   tyvars -- univ tyvars+                                   [tyvar_tys !! i] -- arg types+                                   tycon++                    dc_name = mkWiredInName gHC_PRIM+                                            (mkSumDataConOcc i arity)+                                            (dc_uniq i)+                                            (AConLike (RealDataCon dc))+                                            BuiltInSyntax+                in dc++    tc_uniq   = mkSumTyConUnique   arity+    dc_uniq i = mkSumDataConUnique i arity++{-+************************************************************************+*                                                                      *+              Equality types and classes+*                                                                      *+********************************************************************* -}++-- See Note [The equality types story] in GHC.Builtin.Types.Prim+-- ((~~) :: forall k1 k2 (a :: k1) (b :: k2). a -> b -> Constraint)+--+-- It's tempting to put functional dependencies on (~~), but it's not+-- necessary because the functional-dependency coverage check looks+-- through superclasses, and (~#) is handled in that check.++eqTyCon,   heqTyCon,   coercibleTyCon   :: TyCon+eqClass,   heqClass,   coercibleClass   :: Class+eqDataCon, heqDataCon, coercibleDataCon :: DataCon+eqSCSelId, heqSCSelId, coercibleSCSelId :: Id++(eqTyCon, eqClass, eqDataCon, eqSCSelId)+  = (tycon, klass, datacon, sc_sel_id)+  where+    tycon     = mkClassTyCon eqTyConName binders roles+                             rhs klass+                             (mkPrelTyConRepName eqTyConName)+    klass     = mk_class tycon sc_pred sc_sel_id+    datacon   = pcDataCon eqDataConName tvs [sc_pred] tycon++    -- Kind: forall k. k -> k -> Constraint+    binders   = mkTemplateTyConBinders [liftedTypeKind] (\[k] -> [k,k])+    roles     = [Nominal, Nominal, Nominal]+    rhs       = mkDataTyConRhs [datacon]++    tvs@[k,a,b] = binderVars binders+    sc_pred     = mkTyConApp eqPrimTyCon (mkTyVarTys [k,k,a,b])+    sc_sel_id   = mkDictSelId eqSCSelIdName klass++(heqTyCon, heqClass, heqDataCon, heqSCSelId)+  = (tycon, klass, datacon, sc_sel_id)+  where+    tycon     = mkClassTyCon heqTyConName binders roles+                             rhs klass+                             (mkPrelTyConRepName heqTyConName)+    klass     = mk_class tycon sc_pred sc_sel_id+    datacon   = pcDataCon heqDataConName tvs [sc_pred] tycon++    -- Kind: forall k1 k2. k1 -> k2 -> Constraint+    binders   = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id+    roles     = [Nominal, Nominal, Nominal, Nominal]+    rhs       = mkDataTyConRhs [datacon]++    tvs       = binderVars binders+    sc_pred   = mkTyConApp eqPrimTyCon (mkTyVarTys tvs)+    sc_sel_id = mkDictSelId heqSCSelIdName klass++(coercibleTyCon, coercibleClass, coercibleDataCon, coercibleSCSelId)+  = (tycon, klass, datacon, sc_sel_id)+  where+    tycon     = mkClassTyCon coercibleTyConName binders roles+                             rhs klass+                             (mkPrelTyConRepName coercibleTyConName)+    klass     = mk_class tycon sc_pred sc_sel_id+    datacon   = pcDataCon coercibleDataConName tvs [sc_pred] tycon++    -- Kind: forall k. k -> k -> Constraint+    binders   = mkTemplateTyConBinders [liftedTypeKind] (\[k] -> [k,k])+    roles     = [Nominal, Representational, Representational]+    rhs       = mkDataTyConRhs [datacon]++    tvs@[k,a,b] = binderVars binders+    sc_pred     = mkTyConApp eqReprPrimTyCon (mkTyVarTys [k, k, a, b])+    sc_sel_id   = mkDictSelId coercibleSCSelIdName klass++mk_class :: TyCon -> PredType -> Id -> Class+mk_class tycon sc_pred sc_sel_id+  = mkClass (tyConName tycon) (tyConTyVars tycon) [] [sc_pred] [sc_sel_id]+            [] [] (mkAnd []) tycon++++{- *********************************************************************+*                                                                      *+                Kinds and RuntimeRep+*                                                                      *+********************************************************************* -}++-- For information about the usage of the following type,+-- see Note [TYPE and RuntimeRep] in module GHC.Builtin.Types.Prim+runtimeRepTy :: Type+runtimeRepTy = mkTyConTy runtimeRepTyCon++-- Type synonyms; see Note [TYPE and RuntimeRep] in GHC.Builtin.Types.Prim+-- type Type = tYPE 'LiftedRep+liftedTypeKindTyCon :: TyCon+liftedTypeKindTyCon   = buildSynTyCon liftedTypeKindTyConName+                                       [] liftedTypeKind []+                                       (tYPE liftedRepTy)++runtimeRepTyCon :: TyCon+runtimeRepTyCon = pcTyCon runtimeRepTyConName Nothing []+                          (vecRepDataCon : tupleRepDataCon :+                           sumRepDataCon : runtimeRepSimpleDataCons)++vecRepDataCon :: DataCon+vecRepDataCon = pcSpecialDataCon vecRepDataConName [ mkTyConTy vecCountTyCon+                                                   , mkTyConTy vecElemTyCon ]+                                 runtimeRepTyCon+                                 (RuntimeRep prim_rep_fun)+  where+    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType+    prim_rep_fun [count, elem]+      | VecCount n <- tyConRuntimeRepInfo (tyConAppTyCon count)+      , VecElem  e <- tyConRuntimeRepInfo (tyConAppTyCon elem)+      = [VecRep n e]+    prim_rep_fun args+      = pprPanic "vecRepDataCon" (ppr args)++vecRepDataConTyCon :: TyCon+vecRepDataConTyCon = promoteDataCon vecRepDataCon++tupleRepDataCon :: DataCon+tupleRepDataCon = pcSpecialDataCon tupleRepDataConName [ mkListTy runtimeRepTy ]+                                   runtimeRepTyCon (RuntimeRep prim_rep_fun)+  where+    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType+    prim_rep_fun [rr_ty_list]+      = concatMap (runtimeRepPrimRep doc) rr_tys+      where+        rr_tys = extractPromotedList rr_ty_list+        doc    = text "tupleRepDataCon" <+> ppr rr_tys+    prim_rep_fun args+      = pprPanic "tupleRepDataCon" (ppr args)++tupleRepDataConTyCon :: TyCon+tupleRepDataConTyCon = promoteDataCon tupleRepDataCon++sumRepDataCon :: DataCon+sumRepDataCon = pcSpecialDataCon sumRepDataConName [ mkListTy runtimeRepTy ]+                                 runtimeRepTyCon (RuntimeRep prim_rep_fun)+  where+    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType+    prim_rep_fun [rr_ty_list]+      = map slotPrimRep (ubxSumRepType prim_repss)+      where+        rr_tys     = extractPromotedList rr_ty_list+        doc        = text "sumRepDataCon" <+> ppr rr_tys+        prim_repss = map (runtimeRepPrimRep doc) rr_tys+    prim_rep_fun args+      = pprPanic "sumRepDataCon" (ppr args)++sumRepDataConTyCon :: TyCon+sumRepDataConTyCon = promoteDataCon sumRepDataCon++-- See Note [Wiring in RuntimeRep]+-- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType+runtimeRepSimpleDataCons :: [DataCon]+liftedRepDataCon :: DataCon+runtimeRepSimpleDataCons@(liftedRepDataCon : _)+  = zipWithLazy mk_runtime_rep_dc+    [ LiftedRep, UnliftedRep+    , IntRep+    , Int8Rep, Int16Rep, Int32Rep, Int64Rep+    , WordRep+    , Word8Rep, Word16Rep, Word32Rep, Word64Rep+    , AddrRep+    , FloatRep, DoubleRep+    ]+    runtimeRepSimpleDataConNames+  where+    mk_runtime_rep_dc primrep name+      = pcSpecialDataCon name [] runtimeRepTyCon (RuntimeRep (\_ -> [primrep]))++-- See Note [Wiring in RuntimeRep]+liftedRepDataConTy, unliftedRepDataConTy,+  intRepDataConTy,+  int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,+  wordRepDataConTy,+  word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,+  addrRepDataConTy,+  floatRepDataConTy, doubleRepDataConTy :: Type+[liftedRepDataConTy, unliftedRepDataConTy,+   intRepDataConTy,+   int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,+   wordRepDataConTy,+   word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,+   addrRepDataConTy,+   floatRepDataConTy, doubleRepDataConTy+   ]+  = map (mkTyConTy . promoteDataCon) runtimeRepSimpleDataCons++vecCountTyCon :: TyCon+vecCountTyCon = pcTyCon vecCountTyConName Nothing [] vecCountDataCons++-- See Note [Wiring in RuntimeRep]+vecCountDataCons :: [DataCon]+vecCountDataCons = zipWithLazy mk_vec_count_dc+                     [ 2, 4, 8, 16, 32, 64 ]+                     vecCountDataConNames+  where+    mk_vec_count_dc n name+      = pcSpecialDataCon name [] vecCountTyCon (VecCount n)++-- See Note [Wiring in RuntimeRep]+vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,+  vec64DataConTy :: Type+[vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,+  vec64DataConTy] = map (mkTyConTy . promoteDataCon) vecCountDataCons++vecElemTyCon :: TyCon+vecElemTyCon = pcTyCon vecElemTyConName Nothing [] vecElemDataCons++-- See Note [Wiring in RuntimeRep]+vecElemDataCons :: [DataCon]+vecElemDataCons = zipWithLazy mk_vec_elem_dc+                    [ Int8ElemRep, Int16ElemRep, Int32ElemRep, Int64ElemRep+                    , Word8ElemRep, Word16ElemRep, Word32ElemRep, Word64ElemRep+                    , FloatElemRep, DoubleElemRep ]+                    vecElemDataConNames+  where+    mk_vec_elem_dc elem name+      = pcSpecialDataCon name [] vecElemTyCon (VecElem elem)++-- See Note [Wiring in RuntimeRep]+int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,+  int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,+  word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,+  doubleElemRepDataConTy :: Type+[int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,+  int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,+  word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,+  doubleElemRepDataConTy] = map (mkTyConTy . promoteDataCon)+                                vecElemDataCons++liftedRepDataConTyCon :: TyCon+liftedRepDataConTyCon = promoteDataCon liftedRepDataCon++-- The type ('LiftedRep)+liftedRepTy :: Type+liftedRepTy = liftedRepDataConTy++{- *********************************************************************+*                                                                      *+     The boxed primitive types: Char, Int, etc+*                                                                      *+********************************************************************* -}++boxingDataCon_maybe :: TyCon -> Maybe DataCon+--    boxingDataCon_maybe Char# = C#+--    boxingDataCon_maybe Int#  = I#+--    ... etc ...+-- See Note [Boxing primitive types]+boxingDataCon_maybe tc+  = lookupNameEnv boxing_constr_env (tyConName tc)++boxing_constr_env :: NameEnv DataCon+boxing_constr_env+  = mkNameEnv [(charPrimTyConName  , charDataCon  )+              ,(intPrimTyConName   , intDataCon   )+              ,(wordPrimTyConName  , wordDataCon  )+              ,(floatPrimTyConName , floatDataCon )+              ,(doublePrimTyConName, doubleDataCon) ]++{- Note [Boxing primitive types]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+For a handful of primitive types (Int, Char, Word, Float, Double),+we can readily box and an unboxed version (Int#, Char# etc) using+the corresponding data constructor.  This is useful in a couple+of places, notably let-floating -}+++charTy :: Type+charTy = mkTyConTy charTyCon++charTyCon :: TyCon+charTyCon   = pcTyCon charTyConName+                   (Just (CType NoSourceText Nothing+                                  (NoSourceText,fsLit "HsChar")))+                   [] [charDataCon]+charDataCon :: DataCon+charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon++stringTy :: Type+stringTy = mkListTy charTy -- convenience only++intTy :: Type+intTy = mkTyConTy intTyCon++intTyCon :: TyCon+intTyCon = pcTyCon intTyConName+               (Just (CType NoSourceText Nothing (NoSourceText,fsLit "HsInt")))+                 [] [intDataCon]+intDataCon :: DataCon+intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon++wordTy :: Type+wordTy = mkTyConTy wordTyCon++wordTyCon :: TyCon+wordTyCon = pcTyCon wordTyConName+            (Just (CType NoSourceText Nothing (NoSourceText, fsLit "HsWord")))+               [] [wordDataCon]+wordDataCon :: DataCon+wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon++word8Ty :: Type+word8Ty = mkTyConTy word8TyCon++word8TyCon :: TyCon+word8TyCon = pcTyCon word8TyConName+                     (Just (CType NoSourceText Nothing+                            (NoSourceText, fsLit "HsWord8"))) []+                     [word8DataCon]+word8DataCon :: DataCon+word8DataCon = pcDataCon word8DataConName [] [wordPrimTy] word8TyCon++floatTy :: Type+floatTy = mkTyConTy floatTyCon++floatTyCon :: TyCon+floatTyCon   = pcTyCon floatTyConName+                      (Just (CType NoSourceText Nothing+                             (NoSourceText, fsLit "HsFloat"))) []+                      [floatDataCon]+floatDataCon :: DataCon+floatDataCon = pcDataCon         floatDataConName [] [floatPrimTy] floatTyCon++doubleTy :: Type+doubleTy = mkTyConTy doubleTyCon++doubleTyCon :: TyCon+doubleTyCon = pcTyCon doubleTyConName+                      (Just (CType NoSourceText Nothing+                             (NoSourceText,fsLit "HsDouble"))) []+                      [doubleDataCon]++doubleDataCon :: DataCon+doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon++{-+************************************************************************+*                                                                      *+              The Bool type+*                                                                      *+************************************************************************++An ordinary enumeration type, but deeply wired in.  There are no+magical operations on @Bool@ (just the regular Prelude code).++{\em BEGIN IDLE SPECULATION BY SIMON}++This is not the only way to encode @Bool@.  A more obvious coding makes+@Bool@ just a boxed up version of @Bool#@, like this:+\begin{verbatim}+type Bool# = Int#+data Bool = MkBool Bool#+\end{verbatim}++Unfortunately, this doesn't correspond to what the Report says @Bool@+looks like!  Furthermore, we get slightly less efficient code (I+think) with this coding. @gtInt@ would look like this:++\begin{verbatim}+gtInt :: Int -> Int -> Bool+gtInt x y = case x of I# x# ->+            case y of I# y# ->+            case (gtIntPrim x# y#) of+                b# -> MkBool b#+\end{verbatim}++Notice that the result of the @gtIntPrim@ comparison has to be turned+into an integer (here called @b#@), and returned in a @MkBool@ box.++The @if@ expression would compile to this:+\begin{verbatim}+case (gtInt x y) of+  MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }+\end{verbatim}++I think this code is a little less efficient than the previous code,+but I'm not certain.  At all events, corresponding with the Report is+important.  The interesting thing is that the language is expressive+enough to describe more than one alternative; and that a type doesn't+necessarily need to be a straightforwardly boxed version of its+primitive counterpart.++{\em END IDLE SPECULATION BY SIMON}+-}++boolTy :: Type+boolTy = mkTyConTy boolTyCon++boolTyCon :: TyCon+boolTyCon = pcTyCon boolTyConName+                    (Just (CType NoSourceText Nothing+                           (NoSourceText, fsLit "HsBool")))+                    [] [falseDataCon, trueDataCon]++falseDataCon, trueDataCon :: DataCon+falseDataCon = pcDataCon falseDataConName [] [] boolTyCon+trueDataCon  = pcDataCon trueDataConName  [] [] boolTyCon++falseDataConId, trueDataConId :: Id+falseDataConId = dataConWorkId falseDataCon+trueDataConId  = dataConWorkId trueDataCon++orderingTyCon :: TyCon+orderingTyCon = pcTyCon orderingTyConName Nothing+                        [] [ordLTDataCon, ordEQDataCon, ordGTDataCon]++ordLTDataCon, ordEQDataCon, ordGTDataCon :: DataCon+ordLTDataCon = pcDataCon ordLTDataConName  [] [] orderingTyCon+ordEQDataCon = pcDataCon ordEQDataConName  [] [] orderingTyCon+ordGTDataCon = pcDataCon ordGTDataConName  [] [] orderingTyCon++ordLTDataConId, ordEQDataConId, ordGTDataConId :: Id+ordLTDataConId = dataConWorkId ordLTDataCon+ordEQDataConId = dataConWorkId ordEQDataCon+ordGTDataConId = dataConWorkId ordGTDataCon++{-+************************************************************************+*                                                                      *+            The List type+   Special syntax, deeply wired in,+   but otherwise an ordinary algebraic data type+*                                                                      *+************************************************************************++       data [] a = [] | a : (List a)+-}++mkListTy :: Type -> Type+mkListTy ty = mkTyConApp listTyCon [ty]++listTyCon :: TyCon+listTyCon = pcTyCon listTyConName Nothing [alphaTyVar] [nilDataCon, consDataCon]++-- See also Note [Empty lists] in GHC.Hs.Expr.+nilDataCon :: DataCon+nilDataCon  = pcDataCon nilDataConName alpha_tyvar [] listTyCon++consDataCon :: DataCon+consDataCon = pcDataConWithFixity True {- Declared infix -}+               consDataConName+               alpha_tyvar [] alpha_tyvar+               [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon+-- Interesting: polymorphic recursion would help here.+-- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy+-- gets the over-specific type (Type -> Type)++-- Wired-in type Maybe++maybeTyCon :: TyCon+maybeTyCon = pcTyCon maybeTyConName Nothing alpha_tyvar+                     [nothingDataCon, justDataCon]++nothingDataCon :: DataCon+nothingDataCon = pcDataCon nothingDataConName alpha_tyvar [] maybeTyCon++justDataCon :: DataCon+justDataCon = pcDataCon justDataConName alpha_tyvar [alphaTy] maybeTyCon++{-+** *********************************************************************+*                                                                      *+            The tuple types+*                                                                      *+************************************************************************++The tuple types are definitely magic, because they form an infinite+family.++\begin{itemize}+\item+They have a special family of type constructors, of type @TyCon@+These contain the tycon arity, but don't require a Unique.++\item+They have a special family of constructors, of type+@Id@. Again these contain their arity but don't need a Unique.++\item+There should be a magic way of generating the info tables and+entry code for all tuples.++But at the moment we just compile a Haskell source+file\srcloc{lib/prelude/...} containing declarations like:+\begin{verbatim}+data Tuple0             = Tup0+data Tuple2  a b        = Tup2  a b+data Tuple3  a b c      = Tup3  a b c+data Tuple4  a b c d    = Tup4  a b c d+...+\end{verbatim}+The print-names associated with the magic @Id@s for tuple constructors+``just happen'' to be the same as those generated by these+declarations.++\item+The instance environment should have a magic way to know+that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and+so on. \ToDo{Not implemented yet.}++\item+There should also be a way to generate the appropriate code for each+of these instances, but (like the info tables and entry code) it is+done by enumeration\srcloc{lib/prelude/InTup?.hs}.+\end{itemize}+-}++-- | Make a tuple type. The list of types should /not/ include any+-- RuntimeRep specifications. Boxed 1-tuples are flattened.+-- See Note [One-tuples]+mkTupleTy :: Boxity -> [Type] -> Type+-- Special case for *boxed* 1-tuples, which are represented by the type itself+mkTupleTy Boxed   [ty] = ty+mkTupleTy boxity  tys  = mkTupleTy1 boxity tys++-- | 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 GHC.Core.Make+mkTupleTy1 :: Boxity -> [Type] -> Type+mkTupleTy1 Boxed   tys  = mkTyConApp (tupleTyCon Boxed (length tys)) tys+mkTupleTy1 Unboxed tys  = mkTyConApp (tupleTyCon Unboxed (length tys))+                                         (map getRuntimeRep tys ++ tys)++-- | Build the type of a small tuple that holds the specified type of thing+-- Flattens 1-tuples. See Note [One-tuples].+mkBoxedTupleTy :: [Type] -> Type+mkBoxedTupleTy tys = mkTupleTy Boxed tys++unitTy :: Type+unitTy = mkTupleTy Boxed []++{- *********************************************************************+*                                                                      *+            The sum types+*                                                                      *+************************************************************************+-}++mkSumTy :: [Type] -> Type+mkSumTy tys = mkTyConApp (sumTyCon (length tys))+                         (map getRuntimeRep tys ++ tys)++-- Promoted Booleans++promotedFalseDataCon, promotedTrueDataCon :: TyCon+promotedTrueDataCon   = promoteDataCon trueDataCon+promotedFalseDataCon  = promoteDataCon falseDataCon++-- Promoted Maybe+promotedNothingDataCon, promotedJustDataCon :: TyCon+promotedNothingDataCon = promoteDataCon nothingDataCon+promotedJustDataCon    = promoteDataCon justDataCon++-- Promoted Ordering++promotedLTDataCon+  , promotedEQDataCon+  , promotedGTDataCon+  :: TyCon+promotedLTDataCon     = promoteDataCon ordLTDataCon+promotedEQDataCon     = promoteDataCon ordEQDataCon+promotedGTDataCon     = promoteDataCon ordGTDataCon++-- Promoted List+promotedConsDataCon, promotedNilDataCon :: TyCon+promotedConsDataCon   = promoteDataCon consDataCon+promotedNilDataCon    = promoteDataCon nilDataCon++-- | Make a *promoted* list.+mkPromotedListTy :: Kind   -- ^ of the elements of the list+                 -> [Type] -- ^ elements+                 -> Type+mkPromotedListTy k tys+  = foldr cons nil tys+  where+    cons :: Type  -- element+         -> Type  -- list+         -> Type+    cons elt list = mkTyConApp promotedConsDataCon [k, elt, list]++    nil :: Type+    nil = mkTyConApp promotedNilDataCon [k]++-- | Extract the elements of a promoted list. Panics if the type is not a+-- promoted list+extractPromotedList :: Type    -- ^ The promoted list+                    -> [Type]+extractPromotedList tys = go tys+  where+    go list_ty+      | Just (tc, [_k, t, ts]) <- splitTyConApp_maybe list_ty+      = ASSERT( tc `hasKey` consDataConKey )+        t : go ts++      | Just (tc, [_k]) <- splitTyConApp_maybe list_ty+      = ASSERT( tc `hasKey` nilDataConKey )+        []++      | otherwise+      = pprPanic "extractPromotedList" (ppr tys)
+ compiler/GHC/Builtin/Types.hs-boot view
@@ -0,0 +1,47 @@+module GHC.Builtin.Types where++import {-# SOURCE #-} GHC.Core.TyCon    ( TyCon )+import {-# SOURCE #-} GHC.Core.TyCo.Rep (Type, Kind)++import GHC.Types.Basic (Arity, TupleSort)+import GHC.Types.Name (Name)++listTyCon :: TyCon+typeNatKind, typeSymbolKind :: Type+mkBoxedTupleTy :: [Type] -> Type++coercibleTyCon, heqTyCon :: TyCon++unitTy :: Type++liftedTypeKind :: Kind+liftedTypeKindTyCon :: TyCon++constraintKind :: Kind++runtimeRepTyCon, vecCountTyCon, vecElemTyCon :: TyCon+runtimeRepTy :: Type++liftedRepDataConTyCon, vecRepDataConTyCon, tupleRepDataConTyCon :: TyCon++liftedRepDataConTy, unliftedRepDataConTy,+  intRepDataConTy,+  int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,+  wordRepDataConTy,+  word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,+  addrRepDataConTy,+  floatRepDataConTy, doubleRepDataConTy :: Type++vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,+  vec64DataConTy :: Type++int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,+  int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,+  word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,+  doubleElemRepDataConTy :: Type++anyTypeOfKind :: Kind -> Type+unboxedTupleKind :: [Type] -> Type+mkPromotedListTy :: Type -> [Type] -> Type++tupleTyConName :: TupleSort -> Arity -> Name
+ compiler/GHC/Builtin/Types/Prim.hs view
@@ -0,0 +1,1110 @@+{-+(c) The AQUA Project, Glasgow University, 1994-1998+++Wired-in knowledge about primitive types+-}++{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++-- | This module defines TyCons that can't be expressed in Haskell.+--   They are all, therefore, wired-in TyCons.  C.f module GHC.Builtin.Types+module GHC.Builtin.Types.Prim(+        mkPrimTyConName, -- For implicit parameters in GHC.Builtin.Types only++        mkTemplateKindVars, mkTemplateTyVars, mkTemplateTyVarsFrom,+        mkTemplateKiTyVars, mkTemplateKiTyVar,++        mkTemplateTyConBinders, mkTemplateKindTyConBinders,+        mkTemplateAnonTyConBinders,++        alphaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,+        alphaTys, alphaTy, betaTy, gammaTy, deltaTy,+        alphaTyVarsUnliftedRep, alphaTyVarUnliftedRep,+        alphaTysUnliftedRep, alphaTyUnliftedRep,+        runtimeRep1TyVar, runtimeRep2TyVar, runtimeRep1Ty, runtimeRep2Ty,+        openAlphaTy, openBetaTy, openAlphaTyVar, openBetaTyVar,++        -- Kind constructors...+        tYPETyCon, tYPETyConName,++        -- Kinds+        tYPE, primRepToRuntimeRep,++        funTyCon, funTyConName,+        unexposedPrimTyCons, exposedPrimTyCons, primTyCons,++        charPrimTyCon,          charPrimTy, charPrimTyConName,+        intPrimTyCon,           intPrimTy, intPrimTyConName,+        wordPrimTyCon,          wordPrimTy, wordPrimTyConName,+        addrPrimTyCon,          addrPrimTy, addrPrimTyConName,+        floatPrimTyCon,         floatPrimTy, floatPrimTyConName,+        doublePrimTyCon,        doublePrimTy, doublePrimTyConName,++        voidPrimTyCon,          voidPrimTy,+        statePrimTyCon,         mkStatePrimTy,+        realWorldTyCon,         realWorldTy, realWorldStatePrimTy,++        proxyPrimTyCon,         mkProxyPrimTy,++        arrayPrimTyCon, mkArrayPrimTy,+        byteArrayPrimTyCon,     byteArrayPrimTy,+        arrayArrayPrimTyCon, mkArrayArrayPrimTy,+        smallArrayPrimTyCon, mkSmallArrayPrimTy,+        mutableArrayPrimTyCon, mkMutableArrayPrimTy,+        mutableByteArrayPrimTyCon, mkMutableByteArrayPrimTy,+        mutableArrayArrayPrimTyCon, mkMutableArrayArrayPrimTy,+        smallMutableArrayPrimTyCon, mkSmallMutableArrayPrimTy,+        mutVarPrimTyCon, mkMutVarPrimTy,++        mVarPrimTyCon,                  mkMVarPrimTy,+        tVarPrimTyCon,                  mkTVarPrimTy,+        stablePtrPrimTyCon,             mkStablePtrPrimTy,+        stableNamePrimTyCon,            mkStableNamePrimTy,+        compactPrimTyCon,               compactPrimTy,+        bcoPrimTyCon,                   bcoPrimTy,+        weakPrimTyCon,                  mkWeakPrimTy,+        threadIdPrimTyCon,              threadIdPrimTy,++        int8PrimTyCon,          int8PrimTy, int8PrimTyConName,+        word8PrimTyCon,         word8PrimTy, word8PrimTyConName,++        int16PrimTyCon,         int16PrimTy, int16PrimTyConName,+        word16PrimTyCon,        word16PrimTy, word16PrimTyConName,++        int32PrimTyCon,         int32PrimTy, int32PrimTyConName,+        word32PrimTyCon,        word32PrimTy, word32PrimTyConName,++        int64PrimTyCon,         int64PrimTy, int64PrimTyConName,+        word64PrimTyCon,        word64PrimTy, word64PrimTyConName,++        eqPrimTyCon,            -- ty1 ~# ty2+        eqReprPrimTyCon,        -- ty1 ~R# ty2  (at role Representational)+        eqPhantPrimTyCon,       -- ty1 ~P# ty2  (at role Phantom)+        equalityTyCon,++        -- * SIMD+#include "primop-vector-tys-exports.hs-incl"+  ) where++#include "HsVersions.h"++import GHC.Prelude++import {-# SOURCE #-} GHC.Builtin.Types+  ( runtimeRepTy, unboxedTupleKind, liftedTypeKind+  , vecRepDataConTyCon, tupleRepDataConTyCon+  , liftedRepDataConTy, unliftedRepDataConTy+  , intRepDataConTy+  , int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy+  , wordRepDataConTy+  , word16RepDataConTy, word8RepDataConTy, word32RepDataConTy, word64RepDataConTy+  , addrRepDataConTy+  , floatRepDataConTy, doubleRepDataConTy+  , vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy+  , vec64DataConTy+  , int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy+  , int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy+  , word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy+  , doubleElemRepDataConTy+  , mkPromotedListTy )++import GHC.Types.Var    ( TyVar, mkTyVar )+import GHC.Types.Name+import GHC.Core.TyCon+import GHC.Types.SrcLoc+import GHC.Types.Unique+import GHC.Builtin.Names+import GHC.Data.FastString+import GHC.Utils.Outputable+import GHC.Core.TyCo.Rep -- Doesn't need special access, but this is easier to avoid+                         -- import loops which show up if you import Type instead++import Data.Char++{-+************************************************************************+*                                                                      *+\subsection{Primitive type constructors}+*                                                                      *+************************************************************************+-}++primTyCons :: [TyCon]+primTyCons = unexposedPrimTyCons ++ exposedPrimTyCons++-- | Primitive 'TyCon's that are defined in "GHC.Prim" but not exposed.+-- It's important to keep these separate as we don't want users to be able to+-- write them (see #15209) or see them in GHCi's @:browse@ output+-- (see #12023).+unexposedPrimTyCons :: [TyCon]+unexposedPrimTyCons+  = [ eqPrimTyCon+    , eqReprPrimTyCon+    , eqPhantPrimTyCon+    ]++-- | Primitive 'TyCon's that are defined in, and exported from, "GHC.Prim".+exposedPrimTyCons :: [TyCon]+exposedPrimTyCons+  = [ addrPrimTyCon+    , arrayPrimTyCon+    , byteArrayPrimTyCon+    , arrayArrayPrimTyCon+    , smallArrayPrimTyCon+    , charPrimTyCon+    , doublePrimTyCon+    , floatPrimTyCon+    , intPrimTyCon+    , int8PrimTyCon+    , int16PrimTyCon+    , int32PrimTyCon+    , int64PrimTyCon+    , bcoPrimTyCon+    , weakPrimTyCon+    , mutableArrayPrimTyCon+    , mutableByteArrayPrimTyCon+    , mutableArrayArrayPrimTyCon+    , smallMutableArrayPrimTyCon+    , mVarPrimTyCon+    , tVarPrimTyCon+    , mutVarPrimTyCon+    , realWorldTyCon+    , stablePtrPrimTyCon+    , stableNamePrimTyCon+    , compactPrimTyCon+    , statePrimTyCon+    , voidPrimTyCon+    , proxyPrimTyCon+    , threadIdPrimTyCon+    , wordPrimTyCon+    , word8PrimTyCon+    , word16PrimTyCon+    , word32PrimTyCon+    , word64PrimTyCon++    , tYPETyCon++#include "primop-vector-tycons.hs-incl"+    ]++mkPrimTc :: FastString -> Unique -> TyCon -> Name+mkPrimTc fs unique tycon+  = mkWiredInName gHC_PRIM (mkTcOccFS fs)+                  unique+                  (ATyCon tycon)        -- Relevant TyCon+                  UserSyntax++mkBuiltInPrimTc :: FastString -> Unique -> TyCon -> Name+mkBuiltInPrimTc fs unique tycon+  = mkWiredInName gHC_PRIM (mkTcOccFS fs)+                  unique+                  (ATyCon tycon)        -- Relevant TyCon+                  BuiltInSyntax+++charPrimTyConName, intPrimTyConName, int8PrimTyConName, int16PrimTyConName, int32PrimTyConName, int64PrimTyConName, wordPrimTyConName, word32PrimTyConName, word8PrimTyConName, word16PrimTyConName, word64PrimTyConName, addrPrimTyConName, floatPrimTyConName, doublePrimTyConName, statePrimTyConName, proxyPrimTyConName, realWorldTyConName, arrayPrimTyConName, arrayArrayPrimTyConName, smallArrayPrimTyConName, byteArrayPrimTyConName, mutableArrayPrimTyConName, mutableByteArrayPrimTyConName, mutableArrayArrayPrimTyConName, smallMutableArrayPrimTyConName, mutVarPrimTyConName, mVarPrimTyConName, tVarPrimTyConName, stablePtrPrimTyConName, stableNamePrimTyConName, compactPrimTyConName, bcoPrimTyConName, weakPrimTyConName, threadIdPrimTyConName, eqPrimTyConName, eqReprPrimTyConName, eqPhantPrimTyConName, voidPrimTyConName :: Name+charPrimTyConName             = mkPrimTc (fsLit "Char#") charPrimTyConKey charPrimTyCon+intPrimTyConName              = mkPrimTc (fsLit "Int#") intPrimTyConKey  intPrimTyCon+int8PrimTyConName             = mkPrimTc (fsLit "Int8#") int8PrimTyConKey int8PrimTyCon+int16PrimTyConName            = mkPrimTc (fsLit "Int16#") int16PrimTyConKey int16PrimTyCon+int32PrimTyConName            = mkPrimTc (fsLit "Int32#") int32PrimTyConKey int32PrimTyCon+int64PrimTyConName            = mkPrimTc (fsLit "Int64#") int64PrimTyConKey int64PrimTyCon+wordPrimTyConName             = mkPrimTc (fsLit "Word#") wordPrimTyConKey wordPrimTyCon+word8PrimTyConName            = mkPrimTc (fsLit "Word8#") word8PrimTyConKey word8PrimTyCon+word16PrimTyConName           = mkPrimTc (fsLit "Word16#") word16PrimTyConKey word16PrimTyCon+word32PrimTyConName           = mkPrimTc (fsLit "Word32#") word32PrimTyConKey word32PrimTyCon+word64PrimTyConName           = mkPrimTc (fsLit "Word64#") word64PrimTyConKey word64PrimTyCon+addrPrimTyConName             = mkPrimTc (fsLit "Addr#") addrPrimTyConKey addrPrimTyCon+floatPrimTyConName            = mkPrimTc (fsLit "Float#") floatPrimTyConKey floatPrimTyCon+doublePrimTyConName           = mkPrimTc (fsLit "Double#") doublePrimTyConKey doublePrimTyCon+statePrimTyConName            = mkPrimTc (fsLit "State#") statePrimTyConKey statePrimTyCon+voidPrimTyConName             = mkPrimTc (fsLit "Void#") voidPrimTyConKey voidPrimTyCon+proxyPrimTyConName            = mkPrimTc (fsLit "Proxy#") proxyPrimTyConKey proxyPrimTyCon+eqPrimTyConName               = mkPrimTc (fsLit "~#") eqPrimTyConKey eqPrimTyCon+eqReprPrimTyConName           = mkBuiltInPrimTc (fsLit "~R#") eqReprPrimTyConKey eqReprPrimTyCon+eqPhantPrimTyConName          = mkBuiltInPrimTc (fsLit "~P#") eqPhantPrimTyConKey eqPhantPrimTyCon+realWorldTyConName            = mkPrimTc (fsLit "RealWorld") realWorldTyConKey realWorldTyCon+arrayPrimTyConName            = mkPrimTc (fsLit "Array#") arrayPrimTyConKey arrayPrimTyCon+byteArrayPrimTyConName        = mkPrimTc (fsLit "ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon+arrayArrayPrimTyConName           = mkPrimTc (fsLit "ArrayArray#") arrayArrayPrimTyConKey arrayArrayPrimTyCon+smallArrayPrimTyConName       = mkPrimTc (fsLit "SmallArray#") smallArrayPrimTyConKey smallArrayPrimTyCon+mutableArrayPrimTyConName     = mkPrimTc (fsLit "MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon+mutableByteArrayPrimTyConName = mkPrimTc (fsLit "MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon+mutableArrayArrayPrimTyConName= mkPrimTc (fsLit "MutableArrayArray#") mutableArrayArrayPrimTyConKey mutableArrayArrayPrimTyCon+smallMutableArrayPrimTyConName= mkPrimTc (fsLit "SmallMutableArray#") smallMutableArrayPrimTyConKey smallMutableArrayPrimTyCon+mutVarPrimTyConName           = mkPrimTc (fsLit "MutVar#") mutVarPrimTyConKey mutVarPrimTyCon+mVarPrimTyConName             = mkPrimTc (fsLit "MVar#") mVarPrimTyConKey mVarPrimTyCon+tVarPrimTyConName             = mkPrimTc (fsLit "TVar#") tVarPrimTyConKey tVarPrimTyCon+stablePtrPrimTyConName        = mkPrimTc (fsLit "StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon+stableNamePrimTyConName       = mkPrimTc (fsLit "StableName#") stableNamePrimTyConKey stableNamePrimTyCon+compactPrimTyConName          = mkPrimTc (fsLit "Compact#") compactPrimTyConKey compactPrimTyCon+bcoPrimTyConName              = mkPrimTc (fsLit "BCO#") bcoPrimTyConKey bcoPrimTyCon+weakPrimTyConName             = mkPrimTc (fsLit "Weak#") weakPrimTyConKey weakPrimTyCon+threadIdPrimTyConName         = mkPrimTc (fsLit "ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon++{-+************************************************************************+*                                                                      *+\subsection{Support code}+*                                                                      *+************************************************************************++alphaTyVars is a list of type variables for use in templates:+        ["a", "b", ..., "z", "t1", "t2", ... ]+-}++mkTemplateKindVar :: Kind -> TyVar+mkTemplateKindVar = mkTyVar (mk_tv_name 0 "k")++mkTemplateKindVars :: [Kind] -> [TyVar]+-- k0  with unique (mkAlphaTyVarUnique 0)+-- k1  with unique (mkAlphaTyVarUnique 1)+-- ... etc+mkTemplateKindVars [kind] = [mkTemplateKindVar kind]+  -- Special case for one kind: just "k"+mkTemplateKindVars kinds+  = [ mkTyVar (mk_tv_name u ('k' : show u)) kind+    | (kind, u) <- kinds `zip` [0..] ]+mk_tv_name :: Int -> String -> Name+mk_tv_name u s = mkInternalName (mkAlphaTyVarUnique u)+                                (mkTyVarOccFS (mkFastString s))+                                noSrcSpan++mkTemplateTyVarsFrom :: Int -> [Kind] -> [TyVar]+-- a  with unique (mkAlphaTyVarUnique n)+-- b  with unique (mkAlphaTyVarUnique n+1)+-- ... etc+-- Typically called as+--   mkTemplateTyVarsFrom (length kv_bndrs) kinds+-- where kv_bndrs are the kind-level binders of a TyCon+mkTemplateTyVarsFrom n kinds+  = [ mkTyVar name kind+    | (kind, index) <- zip kinds [0..],+      let ch_ord = index + ord 'a'+          name_str | ch_ord <= ord 'z' = [chr ch_ord]+                   | otherwise         = 't':show index+          name = mk_tv_name (index + n) name_str+    ]++mkTemplateTyVars :: [Kind] -> [TyVar]+mkTemplateTyVars = mkTemplateTyVarsFrom 1++mkTemplateTyConBinders+    :: [Kind]                -- [k1, .., kn]   Kinds of kind-forall'd vars+    -> ([Kind] -> [Kind])    -- Arg is [kv1:k1, ..., kvn:kn]+                             --     same length as first arg+                             -- Result is anon arg kinds+    -> [TyConBinder]+mkTemplateTyConBinders kind_var_kinds mk_anon_arg_kinds+  = kv_bndrs ++ tv_bndrs+  where+    kv_bndrs   = mkTemplateKindTyConBinders kind_var_kinds+    anon_kinds = mk_anon_arg_kinds (mkTyVarTys (binderVars kv_bndrs))+    tv_bndrs   = mkTemplateAnonTyConBindersFrom (length kv_bndrs) anon_kinds++mkTemplateKiTyVars+    :: [Kind]                -- [k1, .., kn]   Kinds of kind-forall'd vars+    -> ([Kind] -> [Kind])    -- Arg is [kv1:k1, ..., kvn:kn]+                             --     same length as first arg+                             -- Result is anon arg kinds [ak1, .., akm]+    -> [TyVar]   -- [kv1:k1, ..., kvn:kn, av1:ak1, ..., avm:akm]+-- Example: if you want the tyvars for+--   forall (r:RuntimeRep) (a:TYPE r) (b:*). blah+-- call mkTemplateKiTyVars [RuntimeRep] (\[r] -> [TYPE r, *])+mkTemplateKiTyVars kind_var_kinds mk_arg_kinds+  = kv_bndrs ++ tv_bndrs+  where+    kv_bndrs   = mkTemplateKindVars kind_var_kinds+    anon_kinds = mk_arg_kinds (mkTyVarTys kv_bndrs)+    tv_bndrs   = mkTemplateTyVarsFrom (length kv_bndrs) anon_kinds++mkTemplateKiTyVar+    :: Kind                  -- [k1, .., kn]   Kind of kind-forall'd var+    -> (Kind -> [Kind])      -- Arg is kv1:k1+                             -- Result is anon arg kinds [ak1, .., akm]+    -> [TyVar]   -- [kv1:k1, ..., kvn:kn, av1:ak1, ..., avm:akm]+-- Example: if you want the tyvars for+--   forall (r:RuntimeRep) (a:TYPE r) (b:*). blah+-- call mkTemplateKiTyVar RuntimeRep (\r -> [TYPE r, *])+mkTemplateKiTyVar kind mk_arg_kinds+  = kv_bndr : tv_bndrs+  where+    kv_bndr    = mkTemplateKindVar kind+    anon_kinds = mk_arg_kinds (mkTyVarTy kv_bndr)+    tv_bndrs   = mkTemplateTyVarsFrom 1 anon_kinds++mkTemplateKindTyConBinders :: [Kind] -> [TyConBinder]+-- Makes named, Specified binders+mkTemplateKindTyConBinders kinds = [mkNamedTyConBinder Specified tv | tv <- mkTemplateKindVars kinds]++mkTemplateAnonTyConBinders :: [Kind] -> [TyConBinder]+mkTemplateAnonTyConBinders kinds = mkAnonTyConBinders VisArg (mkTemplateTyVars kinds)++mkTemplateAnonTyConBindersFrom :: Int -> [Kind] -> [TyConBinder]+mkTemplateAnonTyConBindersFrom n kinds = mkAnonTyConBinders VisArg (mkTemplateTyVarsFrom n kinds)++alphaTyVars :: [TyVar]+alphaTyVars = mkTemplateTyVars $ repeat liftedTypeKind++alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar :: TyVar+(alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars++alphaTys :: [Type]+alphaTys = mkTyVarTys alphaTyVars+alphaTy, betaTy, gammaTy, deltaTy :: Type+(alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys++alphaTyVarsUnliftedRep :: [TyVar]+alphaTyVarsUnliftedRep = mkTemplateTyVars $ repeat (tYPE unliftedRepDataConTy)++alphaTyVarUnliftedRep :: TyVar+(alphaTyVarUnliftedRep:_) = alphaTyVarsUnliftedRep++alphaTysUnliftedRep :: [Type]+alphaTysUnliftedRep = mkTyVarTys alphaTyVarsUnliftedRep+alphaTyUnliftedRep :: Type+(alphaTyUnliftedRep:_) = alphaTysUnliftedRep++runtimeRep1TyVar, runtimeRep2TyVar :: TyVar+(runtimeRep1TyVar : runtimeRep2TyVar : _)+  = drop 16 (mkTemplateTyVars (repeat runtimeRepTy))  -- selects 'q','r'++runtimeRep1Ty, runtimeRep2Ty :: Type+runtimeRep1Ty = mkTyVarTy runtimeRep1TyVar+runtimeRep2Ty = mkTyVarTy runtimeRep2TyVar++openAlphaTyVar, openBetaTyVar :: TyVar+-- alpha :: TYPE r1+-- beta  :: TYPE r2+[openAlphaTyVar,openBetaTyVar]+  = mkTemplateTyVars [tYPE runtimeRep1Ty, tYPE runtimeRep2Ty]++openAlphaTy, openBetaTy :: Type+openAlphaTy = mkTyVarTy openAlphaTyVar+openBetaTy  = mkTyVarTy openBetaTyVar++{-+************************************************************************+*                                                                      *+                FunTyCon+*                                                                      *+************************************************************************+-}++funTyConName :: Name+funTyConName = mkPrimTyConName (fsLit "->") funTyConKey funTyCon++-- | The @(->)@ type constructor.+--+-- @+-- (->) :: forall (rep1 :: RuntimeRep) (rep2 :: RuntimeRep).+--         TYPE rep1 -> TYPE rep2 -> *+-- @+funTyCon :: TyCon+funTyCon = mkFunTyCon funTyConName tc_bndrs tc_rep_nm+  where+    tc_bndrs = [ mkNamedTyConBinder Inferred runtimeRep1TyVar+               , mkNamedTyConBinder Inferred runtimeRep2TyVar ]+               ++ mkTemplateAnonTyConBinders [ tYPE runtimeRep1Ty+                                             , tYPE runtimeRep2Ty+                                             ]+    tc_rep_nm = mkPrelTyConRepName funTyConName++{-+************************************************************************+*                                                                      *+                Kinds+*                                                                      *+************************************************************************++Note [TYPE and RuntimeRep]+~~~~~~~~~~~~~~~~~~~~~~~~~~+All types that classify values have a kind of the form (TYPE rr), where++    data RuntimeRep     -- Defined in ghc-prim:GHC.Types+      = LiftedRep+      | UnliftedRep+      | IntRep+      | FloatRep+      .. etc ..++    rr :: RuntimeRep++    TYPE :: RuntimeRep -> TYPE 'LiftedRep  -- Built in++So for example:+    Int        :: TYPE 'LiftedRep+    Array# Int :: TYPE 'UnliftedRep+    Int#       :: TYPE 'IntRep+    Float#     :: TYPE 'FloatRep+    Maybe      :: TYPE 'LiftedRep -> TYPE 'LiftedRep+    (# , #)    :: TYPE r1 -> TYPE r2 -> TYPE (TupleRep [r1, r2])++We abbreviate '*' specially:+    type * = TYPE 'LiftedRep++The 'rr' parameter tells us how the value is represented at runtime.++Generally speaking, you can't be polymorphic in 'rr'.  E.g+   f :: forall (rr:RuntimeRep) (a:TYPE rr). a -> [a]+   f = /\(rr:RuntimeRep) (a:rr) \(a:rr). ...+This is no good: we could not generate code code for 'f', because the+calling convention for 'f' varies depending on whether the argument is+a a Int, Int#, or Float#.  (You could imagine generating specialised+code, one for each instantiation of 'rr', but we don't do that.)++Certain functions CAN be runtime-rep-polymorphic, because the code+generator never has to manipulate a value of type 'a :: TYPE rr'.++* error :: forall (rr:RuntimeRep) (a:TYPE rr). String -> a+  Code generator never has to manipulate the return value.++* unsafeCoerce#, defined in Desugar.mkUnsafeCoercePair:+  Always inlined to be a no-op+     unsafeCoerce# :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)+                             (a :: TYPE r1) (b :: TYPE r2).+                             a -> b++* Unboxed tuples, and unboxed sums, defined in GHC.Builtin.Types+  Always inlined, and hence specialised to the call site+     (#,#) :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)+                     (a :: TYPE r1) (b :: TYPE r2).+                     a -> b -> TYPE ('TupleRep '[r1, r2])++Note [PrimRep and kindPrimRep]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+As part of its source code, in GHC.Core.TyCon, GHC has+  data PrimRep = LiftedRep | UnliftedRep | IntRep | FloatRep | ...etc...++Notice that+ * RuntimeRep is part of the syntax tree of the program being compiled+     (defined in a library: ghc-prim:GHC.Types)+ * PrimRep is part of GHC's source code.+     (defined in GHC.Core.TyCon)++We need to get from one to the other; that is what kindPrimRep does.+Suppose we have a value+   (v :: t) where (t :: k)+Given this kind+    k = TyConApp "TYPE" [rep]+GHC needs to be able to figure out how 'v' is represented at runtime.+It expects 'rep' to be form+    TyConApp rr_dc args+where 'rr_dc' is a promoteed data constructor from RuntimeRep. So+now we need to go from 'dc' to the corresponding PrimRep.  We store this+PrimRep in the promoted data constructor itself: see TyCon.promDcRepInfo.++-}++tYPETyCon :: TyCon+tYPETyConName :: Name++tYPETyCon = mkKindTyCon tYPETyConName+                        (mkTemplateAnonTyConBinders [runtimeRepTy])+                        liftedTypeKind+                        [Nominal]+                        (mkPrelTyConRepName tYPETyConName)++--------------------------+-- ... and now their names++-- If you edit these, you may need to update the GHC formalism+-- See Note [GHC Formalism] in GHC.Core.Lint+tYPETyConName             = mkPrimTyConName (fsLit "TYPE") tYPETyConKey tYPETyCon++mkPrimTyConName :: FastString -> Unique -> TyCon -> Name+mkPrimTyConName = mkPrimTcName BuiltInSyntax+  -- All of the super kinds and kinds are defined in Prim,+  -- and use BuiltInSyntax, because they are never in scope in the source++mkPrimTcName :: BuiltInSyntax -> FastString -> Unique -> TyCon -> Name+mkPrimTcName built_in_syntax occ key tycon+  = mkWiredInName gHC_PRIM (mkTcOccFS occ) key (ATyCon tycon) built_in_syntax++-----------------------------+-- | Given a RuntimeRep, applies TYPE to it.+-- see Note [TYPE and RuntimeRep]+tYPE :: Type -> Type+tYPE rr = TyConApp tYPETyCon [rr]++{-+************************************************************************+*                                                                      *+   Basic primitive types (@Char#@, @Int#@, etc.)+*                                                                      *+************************************************************************+-}++-- only used herein+pcPrimTyCon :: Name -> [Role] -> PrimRep -> TyCon+pcPrimTyCon name roles rep+  = mkPrimTyCon name binders result_kind roles+  where+    binders     = mkTemplateAnonTyConBinders (map (const liftedTypeKind) roles)+    result_kind = tYPE (primRepToRuntimeRep rep)++-- | Convert a 'PrimRep' to a 'Type' of kind RuntimeRep+-- Defined here to avoid (more) module loops+primRepToRuntimeRep :: PrimRep -> Type+primRepToRuntimeRep rep = case rep of+  VoidRep       -> TyConApp tupleRepDataConTyCon [mkPromotedListTy runtimeRepTy []]+  LiftedRep     -> liftedRepDataConTy+  UnliftedRep   -> unliftedRepDataConTy+  IntRep        -> intRepDataConTy+  Int8Rep       -> int8RepDataConTy+  Int16Rep      -> int16RepDataConTy+  Int32Rep      -> int32RepDataConTy+  Int64Rep      -> int64RepDataConTy+  WordRep       -> wordRepDataConTy+  Word8Rep      -> word8RepDataConTy+  Word16Rep     -> word16RepDataConTy+  Word32Rep     -> word32RepDataConTy+  Word64Rep     -> word64RepDataConTy+  AddrRep       -> addrRepDataConTy+  FloatRep      -> floatRepDataConTy+  DoubleRep     -> doubleRepDataConTy+  VecRep n elem -> TyConApp vecRepDataConTyCon [n', elem']+    where+      n' = case n of+        2  -> vec2DataConTy+        4  -> vec4DataConTy+        8  -> vec8DataConTy+        16 -> vec16DataConTy+        32 -> vec32DataConTy+        64 -> vec64DataConTy+        _  -> pprPanic "Disallowed VecCount" (ppr n)++      elem' = case elem of+        Int8ElemRep   -> int8ElemRepDataConTy+        Int16ElemRep  -> int16ElemRepDataConTy+        Int32ElemRep  -> int32ElemRepDataConTy+        Int64ElemRep  -> int64ElemRepDataConTy+        Word8ElemRep  -> word8ElemRepDataConTy+        Word16ElemRep -> word16ElemRepDataConTy+        Word32ElemRep -> word32ElemRepDataConTy+        Word64ElemRep -> word64ElemRepDataConTy+        FloatElemRep  -> floatElemRepDataConTy+        DoubleElemRep -> doubleElemRepDataConTy++pcPrimTyCon0 :: Name -> PrimRep -> TyCon+pcPrimTyCon0 name rep+  = pcPrimTyCon name [] rep++charPrimTy :: Type+charPrimTy      = mkTyConTy charPrimTyCon+charPrimTyCon :: TyCon+charPrimTyCon   = pcPrimTyCon0 charPrimTyConName WordRep++intPrimTy :: Type+intPrimTy       = mkTyConTy intPrimTyCon+intPrimTyCon :: TyCon+intPrimTyCon    = pcPrimTyCon0 intPrimTyConName IntRep++int8PrimTy :: Type+int8PrimTy     = mkTyConTy int8PrimTyCon+int8PrimTyCon :: TyCon+int8PrimTyCon  = pcPrimTyCon0 int8PrimTyConName Int8Rep++int16PrimTy :: Type+int16PrimTy    = mkTyConTy int16PrimTyCon+int16PrimTyCon :: TyCon+int16PrimTyCon = pcPrimTyCon0 int16PrimTyConName Int16Rep++int32PrimTy :: Type+int32PrimTy     = mkTyConTy int32PrimTyCon+int32PrimTyCon :: TyCon+int32PrimTyCon  = pcPrimTyCon0 int32PrimTyConName Int32Rep++int64PrimTy :: Type+int64PrimTy     = mkTyConTy int64PrimTyCon+int64PrimTyCon :: TyCon+int64PrimTyCon  = pcPrimTyCon0 int64PrimTyConName Int64Rep++wordPrimTy :: Type+wordPrimTy      = mkTyConTy wordPrimTyCon+wordPrimTyCon :: TyCon+wordPrimTyCon   = pcPrimTyCon0 wordPrimTyConName WordRep++word8PrimTy :: Type+word8PrimTy     = mkTyConTy word8PrimTyCon+word8PrimTyCon :: TyCon+word8PrimTyCon  = pcPrimTyCon0 word8PrimTyConName Word8Rep++word16PrimTy :: Type+word16PrimTy    = mkTyConTy word16PrimTyCon+word16PrimTyCon :: TyCon+word16PrimTyCon = pcPrimTyCon0 word16PrimTyConName Word16Rep++word32PrimTy :: Type+word32PrimTy    = mkTyConTy word32PrimTyCon+word32PrimTyCon :: TyCon+word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName Word32Rep++word64PrimTy :: Type+word64PrimTy    = mkTyConTy word64PrimTyCon+word64PrimTyCon :: TyCon+word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep++addrPrimTy :: Type+addrPrimTy      = mkTyConTy addrPrimTyCon+addrPrimTyCon :: TyCon+addrPrimTyCon   = pcPrimTyCon0 addrPrimTyConName AddrRep++floatPrimTy     :: Type+floatPrimTy     = mkTyConTy floatPrimTyCon+floatPrimTyCon :: TyCon+floatPrimTyCon  = pcPrimTyCon0 floatPrimTyConName FloatRep++doublePrimTy :: Type+doublePrimTy    = mkTyConTy doublePrimTyCon+doublePrimTyCon :: TyCon+doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep++{-+************************************************************************+*                                                                      *+   The @State#@ type (and @_RealWorld@ types)+*                                                                      *+************************************************************************++Note [The equality types story]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+GHC sports a veritable menagerie of equality types:++         Type or  Lifted?  Hetero?  Role      Built in         Defining module+         class?    L/U                        TyCon+-----------------------------------------------------------------------------------------+~#         T        U      hetero   nominal   eqPrimTyCon      GHC.Prim+~~         C        L      hetero   nominal   heqTyCon         GHC.Types+~          C        L      homo     nominal   eqTyCon          GHC.Types+:~:        T        L      homo     nominal   (not built-in)   Data.Type.Equality+:~~:       T        L      hetero   nominal   (not built-in)   Data.Type.Equality++~R#        T        U      hetero   repr      eqReprPrimTy     GHC.Prim+Coercible  C        L      homo     repr      coercibleTyCon   GHC.Types+Coercion   T        L      homo     repr      (not built-in)   Data.Type.Coercion+~P#        T        U      hetero   phantom   eqPhantPrimTyCon GHC.Prim++Recall that "hetero" means the equality can related types of different+kinds. Knowing that (t1 ~# t2) or (t1 ~R# t2) or even that (t1 ~P# t2)+also means that (k1 ~# k2), where (t1 :: k1) and (t2 :: k2).++To produce less confusion for end users, when not dumping and without+-fprint-equality-relations, each of these groups is printed as the bottommost+listed equality. That is, (~#) and (~~) are both rendered as (~) in+error messages, and (~R#) is rendered as Coercible.++Let's take these one at a time:++    --------------------------+    (~#) :: forall k1 k2. k1 -> k2 -> #+    --------------------------+This is The Type Of Equality in GHC. It classifies nominal coercions.+This type is used in the solver for recording equality constraints.+It responds "yes" to Type.isEqPrimPred and classifies as an EqPred in+Type.classifyPredType.++All wanted constraints of this type are built with coercion holes.+(See Note [Coercion holes] in GHC.Core.TyCo.Rep.) But see also+Note [Deferred errors for coercion holes] in GHC.Tc.Errors to see how+equality constraints are deferred.++Within GHC, ~# is called eqPrimTyCon, and it is defined in GHC.Builtin.Types.Prim.+++    --------------------------+    (~~) :: forall k1 k2. k1 -> k2 -> Constraint+    --------------------------+This is (almost) an ordinary class, defined as if by+  class a ~# b => a ~~ b+  instance a ~# b => a ~~ b+Here's what's unusual about it:++ * We can't actually declare it that way because we don't have syntax for ~#.+   And ~# isn't a constraint, so even if we could write it, it wouldn't kind+   check.++ * Users cannot write instances of it.++ * It is "naturally coherent". This means that the solver won't hesitate to+   solve a goal of type (a ~~ b) even if there is, say (Int ~~ c) in the+   context. (Normally, it waits to learn more, just in case the given+   influences what happens next.) See Note [Naturally coherent classes]+   in GHC.Tc.Solver.Interact.++ * It always terminates. That is, in the UndecidableInstances checks, we+   don't worry if a (~~) constraint is too big, as we know that solving+   equality terminates.++On the other hand, this behaves just like any class w.r.t. eager superclass+unpacking in the solver. So a lifted equality given quickly becomes an unlifted+equality given. This is good, because the solver knows all about unlifted+equalities. There is some special-casing in GHC.Tc.Solver.Interact.matchClassInst to+pretend that there is an instance of this class, as we can't write the instance+in Haskell.++Within GHC, ~~ is called heqTyCon, and it is defined in GHC.Builtin.Types.+++    --------------------------+    (~) :: forall k. k -> k -> Constraint+    --------------------------+This is /exactly/ like (~~), except with a homogeneous kind.+It is an almost-ordinary class defined as if by+  class a ~# b => (a :: k) ~ (b :: k)+  instance a ~# b => a ~ b++ * All the bullets for (~~) apply++ * In addition (~) is magical syntax, as ~ is a reserved symbol.+   It cannot be exported or imported.++Within GHC, ~ is called eqTyCon, and it is defined in GHC.Builtin.Types.++Historical note: prior to July 18 (~) was defined as a+  more-ordinary class with (~~) as a superclass.  But that made it+  special in different ways; and the extra superclass selections to+  get from (~) to (~#) via (~~) were tiresome.  Now it's defined+  uniformly with (~~) and Coercible; much nicer.)+++    --------------------------+    (:~:) :: forall k. k -> k -> *+    (:~~:) :: forall k1 k2. k1 -> k2 -> *+    --------------------------+These are perfectly ordinary GADTs, wrapping (~) and (~~) resp.+They are not defined within GHC at all.+++    --------------------------+    (~R#) :: forall k1 k2. k1 -> k2 -> #+    --------------------------+The is the representational analogue of ~#. This is the type of representational+equalities that the solver works on. All wanted constraints of this type are+built with coercion holes.++Within GHC, ~R# is called eqReprPrimTyCon, and it is defined in GHC.Builtin.Types.Prim.+++    --------------------------+    Coercible :: forall k. k -> k -> Constraint+    --------------------------+This is quite like (~~) in the way it's defined and treated within GHC, but+it's homogeneous. Homogeneity helps with type inference (as GHC can solve one+kind from the other) and, in my (Richard's) estimation, will be more intuitive+for users.++An alternative design included HCoercible (like (~~)) and Coercible (like (~)).+One annoyance was that we want `coerce :: Coercible a b => a -> b`, and+we need the type of coerce to be fully wired-in. So the HCoercible/Coercible+split required that both types be fully wired-in. Instead of doing this,+I just got rid of HCoercible, as I'm not sure who would use it, anyway.++Within GHC, Coercible is called coercibleTyCon, and it is defined in+GHC.Builtin.Types.+++    --------------------------+    Coercion :: forall k. k -> k -> *+    --------------------------+This is a perfectly ordinary GADT, wrapping Coercible. It is not defined+within GHC at all.+++    --------------------------+    (~P#) :: forall k1 k2. k1 -> k2 -> #+    --------------------------+This is the phantom analogue of ~# and it is barely used at all.+(The solver has no idea about this one.) Here is the motivation:++    data Phant a = MkPhant+    type role Phant phantom++    Phant <Int, Bool>_P :: Phant Int ~P# Phant Bool++We just need to have something to put on that last line. You probably+don't need to worry about it.++++Note [The State# TyCon]+~~~~~~~~~~~~~~~~~~~~~~~+State# is the primitive, unlifted type of states.  It has one type parameter,+thus+        State# RealWorld+or+        State# s++where s is a type variable. The only purpose of the type parameter is to+keep different state threads separate.  It is represented by nothing at all.++The type parameter to State# is intended to keep separate threads separate.+Even though this parameter is not used in the definition of State#, it is+given role Nominal to enforce its intended use.+-}++mkStatePrimTy :: Type -> Type+mkStatePrimTy ty = TyConApp statePrimTyCon [ty]++statePrimTyCon :: TyCon   -- See Note [The State# TyCon]+statePrimTyCon   = pcPrimTyCon statePrimTyConName [Nominal] VoidRep++{-+RealWorld is deeply magical.  It is *primitive*, but it is not+*unlifted* (hence ptrArg).  We never manipulate values of type+RealWorld; it's only used in the type system, to parameterise State#.+-}++realWorldTyCon :: TyCon+realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName [] liftedTypeKind []+realWorldTy :: Type+realWorldTy          = mkTyConTy realWorldTyCon+realWorldStatePrimTy :: Type+realWorldStatePrimTy = mkStatePrimTy realWorldTy        -- State# RealWorld++-- Note: the ``state-pairing'' types are not truly primitive,+-- so they are defined in \tr{GHC.Builtin.Types}, not here.+++voidPrimTy :: Type+voidPrimTy = TyConApp voidPrimTyCon []++voidPrimTyCon :: TyCon+voidPrimTyCon    = pcPrimTyCon voidPrimTyConName [] VoidRep++mkProxyPrimTy :: Type -> Type -> Type+mkProxyPrimTy k ty = TyConApp proxyPrimTyCon [k, ty]++proxyPrimTyCon :: TyCon+proxyPrimTyCon = mkPrimTyCon proxyPrimTyConName binders res_kind [Nominal,Phantom]+  where+     -- Kind: forall k. k -> TYPE (Tuple '[])+     binders = mkTemplateTyConBinders [liftedTypeKind] id+     res_kind = unboxedTupleKind []+++{- *********************************************************************+*                                                                      *+                Primitive equality constraints+    See Note [The equality types story]+*                                                                      *+********************************************************************* -}++eqPrimTyCon :: TyCon  -- The representation type for equality predicates+                      -- See Note [The equality types story]+eqPrimTyCon  = mkPrimTyCon eqPrimTyConName binders res_kind roles+  where+    -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])+    binders  = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id+    res_kind = unboxedTupleKind []+    roles    = [Nominal, Nominal, Nominal, Nominal]++-- like eqPrimTyCon, but the type for *Representational* coercions+-- this should only ever appear as the type of a covar. Its role is+-- interpreted in coercionRole+eqReprPrimTyCon :: TyCon   -- See Note [The equality types story]+eqReprPrimTyCon = mkPrimTyCon eqReprPrimTyConName binders res_kind roles+  where+    -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])+    binders  = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id+    res_kind = unboxedTupleKind []+    roles    = [Nominal, Nominal, Representational, Representational]++-- like eqPrimTyCon, but the type for *Phantom* coercions.+-- This is only used to make higher-order equalities. Nothing+-- should ever actually have this type!+eqPhantPrimTyCon :: TyCon+eqPhantPrimTyCon = mkPrimTyCon eqPhantPrimTyConName binders res_kind roles+  where+    -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])+    binders  = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id+    res_kind = unboxedTupleKind []+    roles    = [Nominal, Nominal, Phantom, Phantom]++-- | Given a Role, what TyCon is the type of equality predicates at that role?+equalityTyCon :: Role -> TyCon+equalityTyCon Nominal          = eqPrimTyCon+equalityTyCon Representational = eqReprPrimTyCon+equalityTyCon Phantom          = eqPhantPrimTyCon++{- *********************************************************************+*                                                                      *+             The primitive array types+*                                                                      *+********************************************************************* -}++arrayPrimTyCon, mutableArrayPrimTyCon, mutableByteArrayPrimTyCon,+    byteArrayPrimTyCon, arrayArrayPrimTyCon, mutableArrayArrayPrimTyCon,+    smallArrayPrimTyCon, smallMutableArrayPrimTyCon :: TyCon+arrayPrimTyCon             = pcPrimTyCon arrayPrimTyConName             [Representational] UnliftedRep+mutableArrayPrimTyCon      = pcPrimTyCon  mutableArrayPrimTyConName     [Nominal, Representational] UnliftedRep+mutableByteArrayPrimTyCon  = pcPrimTyCon mutableByteArrayPrimTyConName  [Nominal] UnliftedRep+byteArrayPrimTyCon         = pcPrimTyCon0 byteArrayPrimTyConName        UnliftedRep+arrayArrayPrimTyCon        = pcPrimTyCon0 arrayArrayPrimTyConName       UnliftedRep+mutableArrayArrayPrimTyCon = pcPrimTyCon mutableArrayArrayPrimTyConName [Nominal] UnliftedRep+smallArrayPrimTyCon        = pcPrimTyCon smallArrayPrimTyConName        [Representational] UnliftedRep+smallMutableArrayPrimTyCon = pcPrimTyCon smallMutableArrayPrimTyConName [Nominal, Representational] UnliftedRep++mkArrayPrimTy :: Type -> Type+mkArrayPrimTy elt           = TyConApp arrayPrimTyCon [elt]+byteArrayPrimTy :: Type+byteArrayPrimTy             = mkTyConTy byteArrayPrimTyCon+mkArrayArrayPrimTy :: Type+mkArrayArrayPrimTy = mkTyConTy arrayArrayPrimTyCon+mkSmallArrayPrimTy :: Type -> Type+mkSmallArrayPrimTy elt = TyConApp smallArrayPrimTyCon [elt]+mkMutableArrayPrimTy :: Type -> Type -> Type+mkMutableArrayPrimTy s elt  = TyConApp mutableArrayPrimTyCon [s, elt]+mkMutableByteArrayPrimTy :: Type -> Type+mkMutableByteArrayPrimTy s  = TyConApp mutableByteArrayPrimTyCon [s]+mkMutableArrayArrayPrimTy :: Type -> Type+mkMutableArrayArrayPrimTy s = TyConApp mutableArrayArrayPrimTyCon [s]+mkSmallMutableArrayPrimTy :: Type -> Type -> Type+mkSmallMutableArrayPrimTy s elt = TyConApp smallMutableArrayPrimTyCon [s, elt]+++{- *********************************************************************+*                                                                      *+                The mutable variable type+*                                                                      *+********************************************************************* -}++mutVarPrimTyCon :: TyCon+mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName [Nominal, Representational] UnliftedRep++mkMutVarPrimTy :: Type -> Type -> Type+mkMutVarPrimTy s elt        = TyConApp mutVarPrimTyCon [s, elt]++{-+************************************************************************+*                                                                      *+   The synchronizing variable type+*                                                                      *+************************************************************************+-}++mVarPrimTyCon :: TyCon+mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName [Nominal, Representational] UnliftedRep++mkMVarPrimTy :: Type -> Type -> Type+mkMVarPrimTy s elt          = TyConApp mVarPrimTyCon [s, elt]++{-+************************************************************************+*                                                                      *+   The transactional variable type+*                                                                      *+************************************************************************+-}++tVarPrimTyCon :: TyCon+tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName [Nominal, Representational] UnliftedRep++mkTVarPrimTy :: Type -> Type -> Type+mkTVarPrimTy s elt = TyConApp tVarPrimTyCon [s, elt]++{-+************************************************************************+*                                                                      *+   The stable-pointer type+*                                                                      *+************************************************************************+-}++stablePtrPrimTyCon :: TyCon+stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName [Representational] AddrRep++mkStablePtrPrimTy :: Type -> Type+mkStablePtrPrimTy ty = TyConApp stablePtrPrimTyCon [ty]++{-+************************************************************************+*                                                                      *+   The stable-name type+*                                                                      *+************************************************************************+-}++stableNamePrimTyCon :: TyCon+stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName [Phantom] UnliftedRep++mkStableNamePrimTy :: Type -> Type+mkStableNamePrimTy ty = TyConApp stableNamePrimTyCon [ty]++{-+************************************************************************+*                                                                      *+   The Compact NFData (CNF) type+*                                                                      *+************************************************************************+-}++compactPrimTyCon :: TyCon+compactPrimTyCon = pcPrimTyCon0 compactPrimTyConName UnliftedRep++compactPrimTy :: Type+compactPrimTy = mkTyConTy compactPrimTyCon++{-+************************************************************************+*                                                                      *+   The ``bytecode object'' type+*                                                                      *+************************************************************************+-}++-- Unlike most other primitive types, BCO is lifted. This is because in+-- general a BCO may be a thunk for the reasons given in Note [Updatable CAF+-- BCOs] in GHCi.CreateBCO.+bcoPrimTy    :: Type+bcoPrimTy    = mkTyConTy bcoPrimTyCon+bcoPrimTyCon :: TyCon+bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName UnliftedRep++{-+************************************************************************+*                                                                      *+   The ``weak pointer'' type+*                                                                      *+************************************************************************+-}++weakPrimTyCon :: TyCon+weakPrimTyCon = pcPrimTyCon weakPrimTyConName [Representational] UnliftedRep++mkWeakPrimTy :: Type -> Type+mkWeakPrimTy v = TyConApp weakPrimTyCon [v]++{-+************************************************************************+*                                                                      *+   The ``thread id'' type+*                                                                      *+************************************************************************++A thread id is represented by a pointer to the TSO itself, to ensure+that they are always unique and we can always find the TSO for a given+thread id.  However, this has the unfortunate consequence that a+ThreadId# for a given thread is treated as a root by the garbage+collector and can keep TSOs around for too long.++Hence the programmer API for thread manipulation uses a weak pointer+to the thread id internally.+-}++threadIdPrimTy :: Type+threadIdPrimTy    = mkTyConTy threadIdPrimTyCon+threadIdPrimTyCon :: TyCon+threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName UnliftedRep++{-+************************************************************************+*                                                                      *+\subsection{SIMD vector types}+*                                                                      *+************************************************************************+-}++#include "primop-vector-tys.hs-incl"
+ compiler/GHC/Builtin/Uniques.hs view
@@ -0,0 +1,180 @@+{-# LANGUAGE CPP #-}++-- | This is where we define a mapping from Uniques to their associated+-- known-key Names for things associated with tuples and sums. We use this+-- mapping while deserializing known-key Names in interface file symbol tables,+-- which are encoded as their Unique. See Note [Symbol table representation of+-- names] for details.+--++module GHC.Builtin.Uniques+    ( -- * Looking up known-key names+      knownUniqueName++      -- * Getting the 'Unique's of 'Name's+      -- ** Anonymous sums+    , mkSumTyConUnique+    , mkSumDataConUnique+      -- ** Tuples+      -- *** Vanilla+    , mkTupleTyConUnique+    , mkTupleDataConUnique+      -- *** Constraint+    , mkCTupleTyConUnique+    , mkCTupleDataConUnique+    ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Builtin.Types+import GHC.Core.TyCon+import GHC.Core.DataCon+import GHC.Types.Id+import GHC.Types.Basic+import GHC.Utils.Outputable+import GHC.Types.Unique+import GHC.Types.Name+import GHC.Utils.Misc++import Data.Bits+import Data.Maybe++-- | Get the 'Name' associated with a known-key 'Unique'.+knownUniqueName :: Unique -> Maybe Name+knownUniqueName u =+    case tag of+      'z' -> Just $ getUnboxedSumName n+      '4' -> Just $ getTupleTyConName Boxed n+      '5' -> Just $ getTupleTyConName Unboxed n+      '7' -> Just $ getTupleDataConName Boxed n+      '8' -> Just $ getTupleDataConName Unboxed n+      'k' -> Just $ getCTupleTyConName n+      'm' -> Just $ getCTupleDataConUnique n+      _   -> Nothing+  where+    (tag, n) = unpkUnique u++--------------------------------------------------+-- Anonymous sums+--+-- Sum arities start from 2. The encoding is a bit funny: we break up the+-- integral part into bitfields for the arity, an alternative index (which is+-- taken to be 0xff in the case of the TyCon), and, in the case of a datacon, a+-- tag (used to identify the sum's TypeRep binding).+--+-- This layout is chosen to remain compatible with the usual unique allocation+-- for wired-in data constructors described in GHC.Types.Unique+--+-- TyCon for sum of arity k:+--   00000000 kkkkkkkk 11111100++-- TypeRep of TyCon for sum of arity k:+--   00000000 kkkkkkkk 11111101+--+-- DataCon for sum of arity k and alternative n (zero-based):+--   00000000 kkkkkkkk nnnnnn00+--+-- TypeRep for sum DataCon of arity k and alternative n (zero-based):+--   00000000 kkkkkkkk nnnnnn10++mkSumTyConUnique :: Arity -> Unique+mkSumTyConUnique arity =+    ASSERT(arity < 0x3f) -- 0x3f since we only have 6 bits to encode the+                         -- alternative+    mkUnique 'z' (arity `shiftL` 8 .|. 0xfc)++mkSumDataConUnique :: ConTagZ -> Arity -> Unique+mkSumDataConUnique alt arity+  | alt >= arity+  = panic ("mkSumDataConUnique: " ++ show alt ++ " >= " ++ show arity)+  | otherwise+  = mkUnique 'z' (arity `shiftL` 8 + alt `shiftL` 2) {- skip the tycon -}++getUnboxedSumName :: Int -> Name+getUnboxedSumName n+  | n .&. 0xfc == 0xfc+  = case tag of+      0x0 -> tyConName $ sumTyCon arity+      0x1 -> getRep $ sumTyCon arity+      _   -> pprPanic "getUnboxedSumName: invalid tag" (ppr tag)+  | tag == 0x0+  = dataConName $ sumDataCon (alt + 1) arity+  | tag == 0x1+  = getName $ dataConWrapId $ sumDataCon (alt + 1) arity+  | tag == 0x2+  = getRep $ promoteDataCon $ sumDataCon (alt + 1) arity+  | otherwise+  = pprPanic "getUnboxedSumName" (ppr n)+  where+    arity = n `shiftR` 8+    alt = (n .&. 0xfc) `shiftR` 2+    tag = 0x3 .&. n+    getRep tycon =+        fromMaybe (pprPanic "getUnboxedSumName(getRep)" (ppr tycon))+        $ tyConRepName_maybe tycon++-- Note [Uniques for tuple type and data constructors]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- Wired-in type constructor keys occupy *two* slots:+--    * u: the TyCon itself+--    * u+1: the TyConRepName of the TyCon+--+-- Wired-in tuple data constructor keys occupy *three* slots:+--    * u: the DataCon itself+--    * u+1: its worker Id+--    * u+2: the TyConRepName of the promoted TyCon++--------------------------------------------------+-- Constraint tuples++mkCTupleTyConUnique :: Arity -> Unique+mkCTupleTyConUnique a = mkUnique 'k' (2*a)++mkCTupleDataConUnique :: Arity -> Unique+mkCTupleDataConUnique a = mkUnique 'm' (3*a)++getCTupleTyConName :: Int -> Name+getCTupleTyConName n =+    case n `divMod` 2 of+      (arity, 0) -> cTupleTyConName arity+      (arity, 1) -> mkPrelTyConRepName $ cTupleTyConName arity+      _          -> panic "getCTupleTyConName: impossible"++getCTupleDataConUnique :: Int -> Name+getCTupleDataConUnique n =+    case n `divMod` 3 of+      (arity,  0) -> cTupleDataConName arity+      (_arity, 1) -> panic "getCTupleDataConName: no worker"+      (arity,  2) -> mkPrelTyConRepName $ cTupleDataConName arity+      _           -> panic "getCTupleDataConName: impossible"++--------------------------------------------------+-- Normal tuples++mkTupleDataConUnique :: Boxity -> Arity -> Unique+mkTupleDataConUnique Boxed          a = mkUnique '7' (3*a)    -- may be used in C labels+mkTupleDataConUnique Unboxed        a = mkUnique '8' (3*a)++mkTupleTyConUnique :: Boxity -> Arity -> Unique+mkTupleTyConUnique Boxed           a  = mkUnique '4' (2*a)+mkTupleTyConUnique Unboxed         a  = mkUnique '5' (2*a)++getTupleTyConName :: Boxity -> Int -> Name+getTupleTyConName boxity n =+    case n `divMod` 2 of+      (arity, 0) -> tyConName $ tupleTyCon boxity arity+      (arity, 1) -> fromMaybe (panic "getTupleTyConName")+                    $ tyConRepName_maybe $ tupleTyCon boxity arity+      _          -> panic "getTupleTyConName: impossible"++getTupleDataConName :: Boxity -> Int -> Name+getTupleDataConName boxity n =+    case n `divMod` 3 of+      (arity, 0) -> dataConName $ tupleDataCon boxity arity+      (arity, 1) -> idName $ dataConWorkId $ tupleDataCon boxity arity+      (arity, 2) -> fromMaybe (panic "getTupleDataCon")+                    $ tyConRepName_maybe $ promotedTupleDataCon boxity arity+      _          -> panic "getTupleDataConName: impossible"
+ compiler/GHC/Builtin/Uniques.hs-boot view
@@ -0,0 +1,18 @@+module GHC.Builtin.Uniques where++import GHC.Prelude+import GHC.Types.Unique+import GHC.Types.Name+import GHC.Types.Basic++-- Needed by GHC.Builtin.Types+knownUniqueName :: Unique -> Maybe Name++mkSumTyConUnique :: Arity -> Unique+mkSumDataConUnique :: ConTagZ -> Arity -> Unique++mkCTupleTyConUnique :: Arity -> Unique+mkCTupleDataConUnique :: Arity -> Unique++mkTupleTyConUnique :: Boxity -> Arity -> Unique+mkTupleDataConUnique :: Boxity -> Arity -> Unique
compiler/GHC/ByteCode/Types.hs view
@@ -13,14 +13,14 @@   , CCostCentre   ) where -import GhcPrelude+import GHC.Prelude -import FastString+import GHC.Data.FastString import GHC.Types.Id import GHC.Types.Name import GHC.Types.Name.Env-import Outputable-import PrimOp+import GHC.Utils.Outputable+import GHC.Builtin.PrimOps import SizedSeq import GHC.Core.Type import GHC.Types.SrcLoc
compiler/GHC/Cmm.hs view
@@ -1,5 +1,8 @@ -- Cmm representations using Hoopl's Graph CmmNode e x. {-# LANGUAGE GADTs #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE ExplicitNamespaces #-}  module GHC.Cmm (      -- * Cmm top-level datatypes@@ -7,7 +10,8 @@      CmmDecl, CmmDeclSRTs, GenCmmDecl(..),      CmmGraph, GenCmmGraph(..),      CmmBlock, RawCmmDecl,-     Section(..), SectionType(..), CmmStatics(..), RawCmmStatics(..), CmmStatic(..),+     Section(..), SectionType(..),+     GenCmmStatics(..), type CmmStatics, type RawCmmStatics, CmmStatic(..),      isSecConstant,       -- ** Blocks containing lists@@ -24,7 +28,7 @@      module GHC.Cmm.Expr,   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Id import GHC.Types.CostCentre@@ -37,7 +41,7 @@ import GHC.Cmm.Dataflow.Collections import GHC.Cmm.Dataflow.Graph import GHC.Cmm.Dataflow.Label-import Outputable+import GHC.Utils.Outputable import Data.ByteString (ByteString)  -----------------------------------------------------------------------------@@ -197,28 +201,31 @@  data CmmStatic   = CmmStaticLit CmmLit-        -- a literal value, size given by cmmLitRep of the literal.+        -- ^ a literal value, size given by cmmLitRep of the literal.   | CmmUninitialised Int-        -- uninitialised data, N bytes long+        -- ^ uninitialised data, N bytes long   | CmmString ByteString-        -- string of 8-bit values only, not zero terminated.+        -- ^ string of 8-bit values only, not zero terminated.+  | CmmFileEmbed FilePath+        -- ^ an embedded binary file  -- Static data before SRT generation-data CmmStatics-  = CmmStatics-      CLabel       -- Label of statics-      CmmInfoTable-      CostCentreStack-      [CmmLit]     -- Payload-  | CmmStaticsRaw-      CLabel       -- Label of statics-      [CmmStatic]  -- The static data itself+data GenCmmStatics (rawOnly :: Bool) where+    CmmStatics+      :: CLabel       -- Label of statics+      -> CmmInfoTable+      -> CostCentreStack+      -> [CmmLit]     -- Payload+      -> GenCmmStatics 'False --- Static data, after SRTs are generated-data RawCmmStatics-   = RawCmmStatics-       CLabel      -- Label of statics-       [CmmStatic] -- The static data itself+    -- | Static data, after SRTs are generated+    CmmStaticsRaw+      :: CLabel       -- Label of statics+      -> [CmmStatic]  -- The static data itself+      -> GenCmmStatics a++type CmmStatics    = GenCmmStatics 'False+type RawCmmStatics = GenCmmStatics 'True  -- ----------------------------------------------------------------------------- -- Basic blocks consisting of lists
compiler/GHC/Cmm/BlockId.hs view
@@ -8,7 +8,7 @@   , blockLbl, infoTblLbl   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Cmm.CLabel import GHC.Types.Id.Info
compiler/GHC/Cmm/CLabel.hs view
@@ -8,6 +8,7 @@  {-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-}+{-# LANGUAGE LambdaCase #-}  module GHC.Cmm.CLabel (         CLabel, -- abstract type@@ -108,29 +109,30 @@         pprCLabel,         isInfoTableLabel,         isConInfoTableLabel,-        isIdLabel+        isIdLabel, isTickyLabel     ) where  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Id.Info import GHC.Types.Basic import {-# SOURCE #-} GHC.Cmm.BlockId (BlockId, mkBlockId)-import GHC.Driver.Packages-import GHC.Types.Module+import GHC.Unit.State+import GHC.Unit import GHC.Types.Name import GHC.Types.Unique-import PrimOp+import GHC.Builtin.PrimOps import GHC.Types.CostCentre-import Outputable-import FastString+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Driver.Session import GHC.Platform import GHC.Types.Unique.Set-import Util+import GHC.Utils.Misc import GHC.Core.Ppr ( {- instances -} )+import GHC.CmmToAsm.Config  -- ----------------------------------------------------------------------------- -- The CLabel type@@ -185,7 +187,7 @@    -- | A label from a .cmm file that is not associated with a .hs level Id.   | CmmLabel-        UnitId               -- what package the label belongs to.+        Unit                    -- what package the label belongs to.         FastString              -- identifier giving the prefix of the label         CmmLabelInfo            -- encodes the suffix of the label @@ -268,6 +270,12 @@ isIdLabel IdLabel{} = True isIdLabel _ = False +-- Used in SRT analysis. See Note [Ticky labels in SRT analysis] in+-- GHC.Cmm.Info.Build.+isTickyLabel :: CLabel -> Bool+isTickyLabel (IdLabel _ _ RednCounts) = True+isTickyLabel _ = 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]@@ -346,7 +354,7 @@ data ForeignLabelSource     -- | Label is in a named package-   = ForeignLabelInPackage      UnitId+   = ForeignLabelInPackage Unit     -- | Label is in some external, system package that doesn't also    --   contain compiled Haskell code, and is not associated with any .hi files.@@ -462,8 +470,7 @@ mkSRTLabel u = SRTLabel u  mkRednCountsLabel :: Name -> CLabel-mkRednCountsLabel       name    =-  IdLabel name NoCafRefs RednCounts  -- Note [ticky for LNE]+mkRednCountsLabel name = IdLabel name NoCafRefs RednCounts  -- Note [ticky for LNE]  -- These have local & (possibly) external variants: mkLocalClosureLabel      :: Name -> CafInfo -> CLabel@@ -546,7 +553,7 @@ ----- mkCmmInfoLabel,   mkCmmEntryLabel, mkCmmRetInfoLabel, mkCmmRetLabel,   mkCmmCodeLabel, mkCmmDataLabel,  mkCmmClosureLabel-        :: UnitId -> FastString -> CLabel+        :: Unit -> FastString -> CLabel  mkCmmInfoLabel      pkg str     = CmmLabel pkg str CmmInfo mkCmmEntryLabel     pkg str     = CmmLabel pkg str CmmEntry@@ -1021,23 +1028,21 @@ -- that data resides in a DLL or not. [Win32 only.] -- @labelDynamic@ returns @True@ if the label is located -- in a DLL, be it a data reference or not.-labelDynamic :: DynFlags -> Module -> CLabel -> Bool-labelDynamic dflags this_mod lbl =+labelDynamic :: NCGConfig -> Module -> CLabel -> Bool+labelDynamic config this_mod lbl =   case lbl of    -- is the RTS in a DLL or not?    RtsLabel _ ->      externalDynamicRefs && (this_pkg /= rtsUnitId)     IdLabel n _ _ ->-     isDynLinkName dflags this_mod n+     externalDynamicRefs && isDynLinkName platform this_mod n     -- When compiling in the "dyn" way, each package is to be linked into    -- its own shared library.    CmmLabel pkg _ _-    | os == OSMinGW32 ->-       externalDynamicRefs && (this_pkg /= pkg)-    | otherwise ->-       gopt Opt_ExternalDynamicRefs dflags+    | os == OSMinGW32 -> externalDynamicRefs && (this_pkg /= pkg)+    | otherwise       -> externalDynamicRefs     LocalBlockLabel _    -> False @@ -1074,9 +1079,10 @@    -- Note that DynamicLinkerLabels do NOT require dynamic linking themselves.    _                 -> False   where-    externalDynamicRefs = gopt Opt_ExternalDynamicRefs dflags-    os = platformOS (targetPlatform dflags)-    this_pkg = moduleUnitId this_mod+    externalDynamicRefs = ncgExternalDynamicRefs config+    platform = ncgPlatform config+    os = platformOS platform+    this_pkg = moduleUnit this_mod   -----------------------------------------------------------------------------@@ -1163,93 +1169,85 @@   ppr c = sdocWithDynFlags $ \dynFlags -> pprCLabel dynFlags c  pprCLabel :: DynFlags -> CLabel -> SDoc--pprCLabel _ (LocalBlockLabel u)-  =  tempLabelPrefixOrUnderscore <> pprUniqueAlways u--pprCLabel dynFlags (AsmTempLabel u)- | not (platformUnregisterised $ targetPlatform dynFlags)-  =  tempLabelPrefixOrUnderscore <> pprUniqueAlways u--pprCLabel dynFlags (AsmTempDerivedLabel l suf)- | platformMisc_ghcWithNativeCodeGen $ platformMisc dynFlags-   = ptext (asmTempLabelPrefix $ targetPlatform dynFlags)-     <> case l of AsmTempLabel u    -> pprUniqueAlways u-                  LocalBlockLabel u -> pprUniqueAlways u-                  _other            -> pprCLabel dynFlags l-     <> ftext suf+pprCLabel dflags = \case+   (LocalBlockLabel u) -> tempLabelPrefixOrUnderscore <> pprUniqueAlways u -pprCLabel dynFlags (DynamicLinkerLabel info lbl)- | platformMisc_ghcWithNativeCodeGen $ platformMisc dynFlags-   = pprDynamicLinkerAsmLabel (targetPlatform dynFlags) info lbl+   (AsmTempLabel u)+      | not (platformUnregisterised platform)+      -> tempLabelPrefixOrUnderscore <> pprUniqueAlways u -pprCLabel dynFlags PicBaseLabel- | platformMisc_ghcWithNativeCodeGen $ platformMisc dynFlags-   = text "1b"+   (AsmTempDerivedLabel l suf)+      | useNCG+      -> ptext (asmTempLabelPrefix platform)+         <> case l of AsmTempLabel u    -> pprUniqueAlways u+                      LocalBlockLabel u -> pprUniqueAlways u+                      _other            -> pprCLabel dflags l+         <> ftext suf -pprCLabel dynFlags (DeadStripPreventer lbl)- | platformMisc_ghcWithNativeCodeGen $ platformMisc dynFlags-   =-   {--      `lbl` can be temp one but we need to ensure that dsp label will stay-      in the final binary so we prepend non-temp prefix ("dsp_") and-      optional `_` (underscore) because this is how you mark non-temp symbols-      on some platforms (Darwin)-   -}-   maybe_underscore dynFlags $ text "dsp_"-   <> pprCLabel dynFlags lbl <> text "_dsp"+   (DynamicLinkerLabel info lbl)+      | useNCG+      -> pprDynamicLinkerAsmLabel platform info lbl -pprCLabel dynFlags (StringLitLabel u)- | platformMisc_ghcWithNativeCodeGen $ platformMisc dynFlags-  = pprUniqueAlways u <> ptext (sLit "_str")+   PicBaseLabel+      | useNCG+      -> text "1b" -pprCLabel dynFlags lbl-   = getPprStyle $ \ sty ->-     if platformMisc_ghcWithNativeCodeGen (platformMisc dynFlags) && asmStyle sty-     then maybe_underscore dynFlags $ pprAsmCLbl (targetPlatform dynFlags) lbl-     else pprCLbl lbl+   (DeadStripPreventer lbl)+      | useNCG+      ->+      {-+         `lbl` can be temp one but we need to ensure that dsp label will stay+         in the final binary so we prepend non-temp prefix ("dsp_") and+         optional `_` (underscore) because this is how you mark non-temp symbols+         on some platforms (Darwin)+      -}+      maybe_underscore $ text "dsp_" <> pprCLabel dflags lbl <> text "_dsp" -maybe_underscore :: DynFlags -> SDoc -> SDoc-maybe_underscore dynFlags doc =-  if platformMisc_leadingUnderscore $ platformMisc dynFlags-  then pp_cSEP <> doc-  else doc+   (StringLitLabel u)+      | useNCG+      -> pprUniqueAlways u <> ptext (sLit "_str") -pprAsmCLbl :: Platform -> CLabel -> SDoc-pprAsmCLbl platform (ForeignLabel fs (Just sz) _ _)- | platformOS platform == OSMinGW32-    -- In asm mode, we need to put the suffix on a stdcall ForeignLabel.-    -- (The C compiler does this itself).-    = ftext fs <> char '@' <> int sz-pprAsmCLbl _ lbl-   = pprCLbl lbl+   lbl -> getPprStyle $ \sty ->+            if useNCG && asmStyle sty+            then maybe_underscore $ pprAsmCLbl lbl+            else pprCLbl dflags lbl -pprCLbl :: CLabel -> SDoc-pprCLbl (StringLitLabel u)-  = pprUniqueAlways u <> text "_str"+  where+    platform = targetPlatform dflags+    useNCG   = platformMisc_ghcWithNativeCodeGen (platformMisc dflags) -pprCLbl (SRTLabel u)-  = tempLabelPrefixOrUnderscore <> pprUniqueAlways u <> pp_cSEP <> text "srt"+    maybe_underscore :: SDoc -> SDoc+    maybe_underscore doc =+      if platformMisc_leadingUnderscore $ platformMisc dflags+      then pp_cSEP <> doc+      else doc -pprCLbl (LargeBitmapLabel u)  =-  tempLabelPrefixOrUnderscore-  <> char 'b' <> pprUniqueAlways u <> pp_cSEP <> text "btm"--- Some bitsmaps for tuple constructors have a numeric tag (e.g. '7')--- until that gets resolved we'll just force them to start--- with a letter so the label will be legal assembly code.+    pprAsmCLbl (ForeignLabel fs (Just sz) _ _)+     | platformOS platform == OSMinGW32+        -- In asm mode, we need to put the suffix on a stdcall ForeignLabel.+        -- (The C compiler does this itself).+        = ftext fs <> char '@' <> int sz+    pprAsmCLbl lbl = pprCLbl dflags lbl +pprCLbl :: DynFlags -> CLabel -> SDoc+pprCLbl dflags = \case+   (StringLitLabel u)   -> pprUniqueAlways u <> text "_str"+   (SRTLabel u)         -> tempLabelPrefixOrUnderscore <> pprUniqueAlways u <> pp_cSEP <> text "srt"+   (LargeBitmapLabel u) -> tempLabelPrefixOrUnderscore+                           <> char 'b' <> pprUniqueAlways u <> pp_cSEP <> text "btm"+                           -- Some bitmaps for tuple constructors have a numeric tag (e.g. '7')+                           -- until that gets resolved we'll just force them to start+                           -- with a letter so the label will be legal assembly code. -pprCLbl (CmmLabel _ str CmmCode)        = ftext str-pprCLbl (CmmLabel _ str CmmData)        = ftext str-pprCLbl (CmmLabel _ str CmmPrimCall)    = ftext str+   (CmmLabel _ str CmmCode)     -> ftext str+   (CmmLabel _ str CmmData)     -> ftext str+   (CmmLabel _ str CmmPrimCall) -> ftext str -pprCLbl (LocalBlockLabel u)             =-    tempLabelPrefixOrUnderscore <> text "blk_" <> pprUniqueAlways u+   (LocalBlockLabel u) -> tempLabelPrefixOrUnderscore <> text "blk_" <> pprUniqueAlways u -pprCLbl (RtsLabel (RtsApFast str))   = ftext str <> text "_fast"+   (RtsLabel (RtsApFast str)) -> ftext str <> text "_fast" -pprCLbl (RtsLabel (RtsSelectorInfoTable upd_reqd offset))-  = sdocWithDynFlags $ \dflags ->+   (RtsLabel (RtsSelectorInfoTable upd_reqd offset)) ->     ASSERT(offset >= 0 && offset <= mAX_SPEC_SELECTEE_SIZE dflags)     hcat [text "stg_sel_", text (show offset),           ptext (if upd_reqd@@ -1257,8 +1255,7 @@                  else (sLit "_noupd_info"))         ] -pprCLbl (RtsLabel (RtsSelectorEntry upd_reqd offset))-  = sdocWithDynFlags $ \dflags ->+   (RtsLabel (RtsSelectorEntry upd_reqd offset)) ->     ASSERT(offset >= 0 && offset <= mAX_SPEC_SELECTEE_SIZE dflags)     hcat [text "stg_sel_", text (show offset),                 ptext (if upd_reqd@@ -1266,8 +1263,7 @@                         else (sLit "_noupd_entry"))         ] -pprCLbl (RtsLabel (RtsApInfoTable upd_reqd arity))-  = sdocWithDynFlags $ \dflags ->+   (RtsLabel (RtsApInfoTable upd_reqd arity)) ->     ASSERT(arity > 0 && arity <= mAX_SPEC_AP_SIZE dflags)     hcat [text "stg_ap_", text (show arity),                 ptext (if upd_reqd@@ -1275,8 +1271,7 @@                         else (sLit "_noupd_info"))         ] -pprCLbl (RtsLabel (RtsApEntry upd_reqd arity))-  = sdocWithDynFlags $ \dflags ->+   (RtsLabel (RtsApEntry upd_reqd arity)) ->     ASSERT(arity > 0 && arity <= mAX_SPEC_AP_SIZE dflags)     hcat [text "stg_ap_", text (show arity),                 ptext (if upd_reqd@@ -1284,44 +1279,29 @@                         else (sLit "_noupd_entry"))         ] -pprCLbl (CmmLabel _ fs CmmInfo)-  = ftext fs <> text "_info"--pprCLbl (CmmLabel _ fs CmmEntry)-  = ftext fs <> text "_entry"--pprCLbl (CmmLabel _ fs CmmRetInfo)-  = ftext fs <> text "_info"--pprCLbl (CmmLabel _ fs CmmRet)-  = ftext fs <> text "_ret"--pprCLbl (CmmLabel _ fs CmmClosure)-  = ftext fs <> text "_closure"--pprCLbl (RtsLabel (RtsPrimOp primop))-  = text "stg_" <> ppr primop--pprCLbl (RtsLabel (RtsSlowFastTickyCtr pat))-  = text "SLOW_CALL_fast_" <> text pat <> ptext (sLit "_ctr")+   (CmmLabel _ fs CmmInfo)    -> ftext fs <> text "_info"+   (CmmLabel _ fs CmmEntry)   -> ftext fs <> text "_entry"+   (CmmLabel _ fs CmmRetInfo) -> ftext fs <> text "_info"+   (CmmLabel _ fs CmmRet)     -> ftext fs <> text "_ret"+   (CmmLabel _ fs CmmClosure) -> ftext fs <> text "_closure" -pprCLbl (ForeignLabel str _ _ _)-  = ftext str+   (RtsLabel (RtsPrimOp primop)) -> text "stg_" <> ppr primop+   (RtsLabel (RtsSlowFastTickyCtr pat)) ->+      text "SLOW_CALL_fast_" <> text pat <> ptext (sLit "_ctr") -pprCLbl (IdLabel name _cafs flavor) =-  internalNamePrefix name <> ppr name <> ppIdFlavor flavor+   (ForeignLabel str _ _ _) -> ftext str -pprCLbl (CC_Label cc)           = ppr cc-pprCLbl (CCS_Label ccs)         = ppr ccs+   (IdLabel name _cafs flavor) -> internalNamePrefix name <> ppr name <> ppIdFlavor flavor -pprCLbl (HpcTicksLabel mod)-  = text "_hpc_tickboxes_"  <> ppr mod <> ptext (sLit "_hpc")+   (CC_Label cc)       -> ppr cc+   (CCS_Label ccs)     -> ppr ccs+   (HpcTicksLabel mod) -> text "_hpc_tickboxes_"  <> ppr mod <> ptext (sLit "_hpc") -pprCLbl (AsmTempLabel {})       = panic "pprCLbl AsmTempLabel"-pprCLbl (AsmTempDerivedLabel {})= panic "pprCLbl AsmTempDerivedLabel"-pprCLbl (DynamicLinkerLabel {}) = panic "pprCLbl DynamicLinkerLabel"-pprCLbl (PicBaseLabel {})       = panic "pprCLbl PicBaseLabel"-pprCLbl (DeadStripPreventer {}) = panic "pprCLbl DeadStripPreventer"+   (AsmTempLabel {})        -> panic "pprCLbl AsmTempLabel"+   (AsmTempDerivedLabel {}) -> panic "pprCLbl AsmTempDerivedLabel"+   (DynamicLinkerLabel {})  -> panic "pprCLbl DynamicLinkerLabel"+   (PicBaseLabel {})        -> panic "pprCLbl PicBaseLabel"+   (DeadStripPreventer {})  -> panic "pprCLbl DeadStripPreventer"  ppIdFlavor :: IdLabelInfo -> SDoc ppIdFlavor x = pp_cSEP <> text
compiler/GHC/Cmm/Dataflow/Block.hs view
@@ -38,7 +38,7 @@     , replaceLastNode     ) where -import GhcPrelude+import GHC.Prelude  -- ----------------------------------------------------------------------------- -- Shapes: Open and Closed
compiler/GHC/Cmm/Dataflow/Collections.hs view
@@ -12,7 +12,7 @@     , UniqueMap, UniqueSet     ) where -import GhcPrelude+import GHC.Prelude  import qualified Data.IntMap.Strict as M import qualified Data.IntSet as S
compiler/GHC/Cmm/Dataflow/Graph.hs view
@@ -20,8 +20,8 @@     ) where  -import GhcPrelude-import Util+import GHC.Prelude+import GHC.Utils.Misc  import GHC.Cmm.Dataflow.Label import GHC.Cmm.Dataflow.Block
compiler/GHC/Cmm/Dataflow/Label.hs view
@@ -13,15 +13,15 @@     , mkHooplLabel     ) where -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable  -- TODO: This should really just use GHC's Unique and Uniq{Set,FM} import GHC.Cmm.Dataflow.Collections  import GHC.Types.Unique (Uniquable(..))-import TrieMap+import GHC.Data.TrieMap   -----------------------------------------------------------------------------
compiler/GHC/Cmm/Expr.hs view
@@ -31,7 +31,7 @@     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Platform import GHC.Cmm.BlockId@@ -39,7 +39,7 @@ import GHC.Cmm.MachOp import GHC.Cmm.Type import GHC.Driver.Session-import Outputable (panic)+import GHC.Utils.Outputable (panic) import GHC.Types.Unique  import Data.Set (Set)@@ -368,7 +368,7 @@  instance (Ord r, UserOfRegs r CmmReg) => UserOfRegs r CmmExpr where   -- The (Ord r) in the context is necessary here-  -- See Note [Recursive superclasses] in TcInstDcls+  -- See Note [Recursive superclasses] in GHC.Tc.TyCl.Instance   foldRegsUsed dflags f !z e = expr z e     where expr z (CmmLit _)          = z           expr z (CmmLoad addr _)    = foldRegsUsed dflags f z addr
compiler/GHC/Cmm/MachOp.hs view
@@ -28,11 +28,11 @@    ) where -import GhcPrelude+import GHC.Prelude  import GHC.Platform import GHC.Cmm.Type-import Outputable+import GHC.Utils.Outputable  ----------------------------------------------------------------------------- --              MachOp
compiler/GHC/Cmm/Node.hs view
@@ -26,15 +26,15 @@      CmmTickScope(..), isTickSubScope, combineTickScopes,   ) where -import GhcPrelude hiding (succ)+import GHC.Prelude hiding (succ)  import GHC.Platform.Regs import GHC.Cmm.Expr import GHC.Cmm.Switch import GHC.Driver.Session-import FastString+import GHC.Data.FastString import GHC.Types.ForeignCall-import Outputable+import GHC.Utils.Outputable import GHC.Runtime.Heap.Layout import GHC.Core (Tickish) import qualified GHC.Types.Unique as U@@ -46,7 +46,7 @@ import Data.Maybe import Data.List (tails,sortBy) import GHC.Types.Unique (nonDetCmpUnique)-import Util+import GHC.Utils.Misc   ------------------------@@ -348,7 +348,7 @@  instance (Ord r, UserOfRegs r CmmReg) => UserOfRegs r ForeignTarget where   -- The (Ord r) in the context is necessary here-  -- See Note [Recursive superclasses] in TcInstDcls+  -- See Note [Recursive superclasses] in GHC.Tc.TyCl.Instance   foldRegsUsed _      _ !z (PrimTarget _)      = z   foldRegsUsed dflags f !z (ForeignTarget e _) = foldRegsUsed dflags f z e
compiler/GHC/Cmm/Switch.hs view
@@ -12,9 +12,9 @@      createSwitchPlan,   ) where -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable import GHC.Driver.Session import GHC.Cmm.Dataflow.Label (Label)
compiler/GHC/Cmm/Type.hs view
@@ -29,12 +29,12 @@ where  -import GhcPrelude+import GHC.Prelude  import GHC.Platform import GHC.Driver.Session-import FastString-import Outputable+import GHC.Data.FastString+import GHC.Utils.Outputable  import Data.Word import Data.Int
+ compiler/GHC/CmmToAsm/Config.hs view
@@ -0,0 +1,44 @@+-- | Native code generator configuration+module GHC.CmmToAsm.Config+   ( NCGConfig(..)+   , ncgWordWidth+   , platformWordWidth+   )+where++import GHC.Prelude+import GHC.Platform+import GHC.Cmm.Type (Width(..))+import GHC.Unit.Module++-- | Native code generator configuration+data NCGConfig = NCGConfig+   { ncgPlatform              :: !Platform        -- ^ Target platform+   , ncgUnitId                :: Unit             -- ^ Target unit ID+   , ncgProcAlignment         :: !(Maybe Int)     -- ^ Mandatory proc alignment+   , ncgDebugLevel            :: !Int             -- ^ Debug level+   , ncgExternalDynamicRefs   :: !Bool            -- ^ Generate code to link against dynamic libraries+   , ncgPIC                   :: !Bool            -- ^ Enable Position-Independent Code+   , ncgInlineThresholdMemcpy :: !Word            -- ^ If inlining `memcpy` produces less than this threshold (in pseudo-instruction unit), do it+   , ncgInlineThresholdMemset :: !Word            -- ^ Ditto for `memset`+   , ncgSplitSections         :: !Bool            -- ^ Split sections+   , ncgSpillPreallocSize     :: !Int             -- ^ Size in bytes of the pre-allocated spill space on the C stack+   , ncgRegsIterative         :: !Bool+   , ncgAsmLinting            :: !Bool            -- ^ Perform ASM linting pass+   , ncgDoConstantFolding     :: !Bool            -- ^ Perform CMM constant folding+   , ncgSseVersion            :: Maybe SseVersion -- ^ (x86) SSE instructions+   , ncgBmiVersion            :: Maybe BmiVersion -- ^ (x86) BMI instructions+   , ncgDumpRegAllocStages    :: !Bool+   , ncgDumpAsmStats          :: !Bool+   , ncgDumpAsmConflicts      :: !Bool+   }++-- | Return Word size+ncgWordWidth :: NCGConfig -> Width+ncgWordWidth config = platformWordWidth (ncgPlatform config)++-- | Return Word size+platformWordWidth :: Platform -> Width+platformWordWidth platform = case platformWordSize platform of+   PW4 -> W32+   PW8 -> W64
compiler/GHC/Core.hs view
@@ -69,7 +69,7 @@         maybeUnfoldingTemplate, otherCons,         isValueUnfolding, isEvaldUnfolding, isCheapUnfolding,         isExpandableUnfolding, isConLikeUnfolding, isCompulsoryUnfolding,-        isStableUnfolding, isFragileUnfolding, hasSomeUnfolding,+        isStableUnfolding, hasCoreUnfolding, hasSomeUnfolding,         isBootUnfolding,         canUnfold, neverUnfoldGuidance, isStableSource, @@ -99,7 +99,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude import GHC.Platform  import GHC.Types.CostCentre@@ -112,13 +112,13 @@ import GHC.Types.Name.Env( NameEnv, emptyNameEnv ) import GHC.Types.Literal import GHC.Core.DataCon-import GHC.Types.Module+import GHC.Unit.Module import GHC.Types.Basic-import Outputable-import Util+import GHC.Utils.Outputable+import GHC.Utils.Misc import GHC.Types.Unique.Set import GHC.Types.SrcLoc ( RealSrcSpan, containsSpan )-import Binary+import GHC.Utils.Binary  import Data.Data hiding (TyCon) import Data.Int@@ -354,7 +354,7 @@  Also, we do not permit case analysis with literal patterns on floating-point types. See #9238 and Note [Rules for floating-point comparisons] in-GHC.Core.Op.ConstantFold for the rationale for this restriction.+GHC.Core.Opt.ConstantFold for the rationale for this restriction.  -------------------------- GHC.Core INVARIANTS --------------------------- @@ -451,7 +451,7 @@ GHC.Core.Make.  For discussion of some implications of the let/app invariant primops see-Note [Checking versus non-checking primops] in PrimOp.+Note [Checking versus non-checking primops] in GHC.Builtin.PrimOps.  Note [Case expression invariants] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -508,7 +508,7 @@  5. Floating-point values must not be scrutinised against literals.    See #9238 and Note [Rules for floating-point comparisons]-   in GHC.Core.Op.ConstantFold for rationale.  Checked in lintCaseExpr;+   in GHC.Core.Opt.ConstantFold 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@@ -537,7 +537,7 @@       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+  in GHC.Tc.Solver.Canonical  Note [Core case invariants] ~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -784,7 +784,7 @@     _  -> False  The simplifier will pull the case into the join point (see Note [Join points-and case-of-case] in GHC.Core.Op.Simplify):+and case-of-case] in GHC.Core.Opt.Simplify):    join     j :: Int -> Bool -> Bool -- changed!@@ -1296,7 +1296,7 @@ ************************************************************************  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+GHC.Core.FVs, GHC.Core.Subst, GHC.Core.Ppr, GHC.Core.Tidy also inspect the representation. -} @@ -1739,14 +1739,13 @@ 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+hasCoreUnfolding :: Unfolding -> Bool+-- An unfolding "has Core" if it contains a Core expression, which+-- may mention free variables. See Note [Fragile unfoldings]+hasCoreUnfolding (CoreUnfolding {}) = True+hasCoreUnfolding (DFunUnfolding {}) = True+hasCoreUnfolding _                  = False+  -- NoUnfolding, BootUnfolding, OtherCon have no Core  canUnfold :: Unfolding -> Bool canUnfold (CoreUnfolding { uf_guidance = g }) = not (neverUnfoldGuidance g)@@ -1817,7 +1816,7 @@ -}  -- The Ord is needed for the FiniteMap used in the lookForConstructor--- in GHC.Core.Op.Simplify.Env.  If you declared that lookForConstructor+-- in GHC.Core.Opt.Simplify.Env.  If you declared that lookForConstructor -- *ignores* constructor-applications with LitArg args, then you could get rid -- of this Ord.
compiler/GHC/Core/Arity.hs view
@@ -21,7 +21,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core import GHC.Core.FVs@@ -38,9 +38,9 @@ import GHC.Types.Basic import GHC.Types.Unique import GHC.Driver.Session ( DynFlags, GeneralFlag(..), gopt )-import Outputable-import FastString-import Util     ( debugIsOn )+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Utils.Misc     ( debugIsOn )  {- ************************************************************************@@ -191,7 +191,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~     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+    at all.  See Note [Single-method classes] in GHC.Tc.TyCl.Instance. SLPJ May 2013  -------- Old out of date comments, just for interest ----------- We have to be careful when eta-expanding through newtypes.  In general
compiler/GHC/Core/Class.hs view
@@ -23,7 +23,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.TyCon    ( TyCon ) import {-# SOURCE #-} GHC.Core.TyCo.Rep ( Type, PredType )@@ -32,10 +32,10 @@ import GHC.Types.Name import GHC.Types.Basic import GHC.Types.Unique-import Util+import GHC.Utils.Misc import GHC.Types.SrcLoc-import Outputable-import BooleanFormula (BooleanFormula, mkTrue)+import GHC.Utils.Outputable+import GHC.Data.BooleanFormula (BooleanFormula, mkTrue)  import qualified Data.Data as Data @@ -79,7 +79,7 @@ -- --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow'', --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation type FunDep a = ([a],[a])  type ClassOpItem = (Id, DefMethInfo)@@ -222,7 +222,7 @@ header.  Having the same variables for class and tycon is also used in checkValidRoles-(in TcTyClsDecls) when checking a class's roles.+(in GHC.Tc.TyCl) when checking a class's roles.   ************************************************************************
compiler/GHC/Core/Coercion.hs view
@@ -121,7 +121,7 @@  import {-# SOURCE #-} GHC.CoreToIface (toIfaceTyCon, tidyToIfaceTcArgs) -import GhcPrelude+import GHC.Prelude  import GHC.Iface.Type import GHC.Core.TyCo.Rep@@ -136,16 +136,16 @@ import GHC.Types.Var.Env import GHC.Types.Var.Set import GHC.Types.Name hiding ( varName )-import Util+import GHC.Utils.Misc import GHC.Types.Basic-import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique-import Pair+import GHC.Data.Pair import GHC.Types.SrcLoc-import PrelNames-import TysPrim-import ListSetOps-import Maybes+import GHC.Builtin.Names+import GHC.Builtin.Types.Prim+import GHC.Data.List.SetOps+import GHC.Data.Maybe import GHC.Types.Unique.FM  import Control.Monad (foldM, zipWithM)@@ -207,7 +207,7 @@  pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc -- Used when printing injectivity errors (FamInst.reportInjectivityErrors)--- and inaccessible branches (TcValidity.inaccessibleCoAxBranch)+-- and inaccessible branches (GHC.Tc.Validity.inaccessibleCoAxBranch) -- This happens in error messages: don't print the RHS of a data --   family axiom, which is meaningless to a user pprCoAxBranchUser tc br@@ -245,7 +245,7 @@      -- Eta-expand LHS and RHS types, because sometimes data family     -- instances are eta-reduced.-    -- See Note [Eta reduction for data families] in GHC.Core.FamInstEnv.+    -- See Note [Eta reduction for data families] in GHC.Core.Coercion.Axiom.     (ee_tvs, ee_lhs, ee_rhs) = etaExpandCoAxBranch branch      pp_lhs = pprIfaceTypeApp topPrec (toIfaceTyCon fam_tc)@@ -1503,7 +1503,7 @@                   -- We didn't call mkForAllCo here because if v does not appear                   -- in co, the argement coercion will be nominal. But here we                   -- want it to be r. It is only called in 'mkPiCos', which is-                  -- only used in GHC.Core.Op.Simplify.Utils, where we are sure for+                  -- only used in GHC.Core.Opt.Simplify.Utils, where we are sure for                   -- now (Aug 2018) v won't occur in co.                             mkFunCo r (mkReflCo r (varType v)) co               | otherwise = mkFunCo r (mkReflCo r (varType v)) co@@ -2524,7 +2524,7 @@ %*                                                                      * %************************************************************************ -The function below morally belongs in TcFlatten, but it is used also in+The function below morally belongs in GHC.Tc.Solver.Flatten, but it is used also in FamInstEnv, and so lives here.  Note [simplifyArgsWorker]@@ -2838,7 +2838,7 @@         kind_co = liftCoSubst Nominal lc final_kind      go acc_xis acc_cos lc (binder:binders) inner_ki (role:roles) ((xi,co):args)-      = -- By Note [Flattening] in TcFlatten invariant (F2),+      = -- By Note [Flattening] in GHC.Tc.Solver.Flatten invariant (F2),          -- tcTypeKind(xi) = tcTypeKind(ty). But, it's possible that xi will be          -- used as an argument to a function whose kind is different, if          -- earlier arguments have been flattened to new types. We thus@@ -2898,7 +2898,7 @@            -- This debug information is commented out because leaving it in            -- causes a ~2% increase in allocations in T9872d.            -- That's independent of the analogous case in flatten_args_fast-           -- in TcFlatten:+           -- in GHC.Tc.Solver.Flatten:            -- each of these causes a 2% increase on its own, so commenting them            -- both out gives a 4% decrease in T9872d.            {-
compiler/GHC/Core/Coercion.hs-boot view
@@ -2,7 +2,7 @@  module GHC.Core.Coercion where -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.TyCo.Rep import {-# SOURCE #-} GHC.Core.TyCon@@ -10,8 +10,8 @@ import GHC.Types.Basic ( LeftOrRight ) import GHC.Core.Coercion.Axiom import GHC.Types.Var-import Pair-import Util+import GHC.Data.Pair+import GHC.Utils.Misc  mkReflCo :: Role -> Type -> Coercion mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion
compiler/GHC/Core/Coercion/Axiom.hs view
@@ -29,19 +29,19 @@        BuiltInSynFamily(..)        ) where -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.TyCo.Rep ( Type ) import {-# SOURCE #-} GHC.Core.TyCo.Ppr ( pprType ) import {-# SOURCE #-} GHC.Core.TyCon    ( TyCon )-import Outputable-import FastString+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Types.Name import GHC.Types.Unique import GHC.Types.Var-import Util-import Binary-import Pair+import GHC.Utils.Misc+import GHC.Utils.Binary+import GHC.Data.Pair import GHC.Types.Basic import Data.Typeable ( Typeable ) import GHC.Types.SrcLoc@@ -235,12 +235,12 @@     , cab_tvs      :: [TyVar]       -- Bound type variables; not necessarily fresh     , cab_eta_tvs  :: [TyVar]       -- Eta-reduced tyvars                                     -- See Note [CoAxBranch type variables]-                                    -- cab_tvs and cab_lhs may be eta-reduded; see+                                    -- cab_tvs and cab_lhs may be eta-reduced; see                                     -- Note [Eta reduction for data families]     , cab_cvs      :: [CoVar]       -- Bound coercion variables                                     -- Always empty, for now.                                     -- See Note [Constraints in patterns]-                                    -- in TcTyClsDecls+                                    -- in GHC.Tc.TyCl     , cab_roles    :: [Role]        -- See Note [CoAxBranch roles]     , cab_lhs      :: [Type]        -- Type patterns to match against     , cab_rhs      :: Type          -- Right-hand side of the equality@@ -427,7 +427,7 @@   - This eta reduction happens for data instances as well     as newtype instances. Here we want to eta-reduce the data family axiom. -  - This eta-reduction is done in TcInstDcls.tcDataFamInstDecl.+  - This eta-reduction is done in GHC.Tc.TyCl.Instance.tcDataFamInstDecl.  But for a /type/ family   - cab_lhs has the exact arity of the family tycon@@ -443,9 +443,13 @@ (See #9692, #14179, and #15845 for examples of what can go wrong if we don't eta-expand when showing things to the user.) -(See also Note [Newtype eta] in GHC.Core.TyCon.  This is notionally separate-and deals with the axiom connecting a newtype with its representation-type; but it too is eta-reduced.)+See also:++* Note [Newtype eta] in GHC.Core.TyCon.  This is notionally separate+  and deals with the axiom connecting a newtype with its representation+  type; but it too is eta-reduced.+* Note [Implementing eta reduction for data families] in TcInstDcls. This+  describes the implementation details of this eta reduction happen. -}  instance Eq (CoAxiom br) where@@ -496,7 +500,7 @@ -- These names are slurped into the parser code. Changing these strings -- will change the **surface syntax** that GHC accepts! If you want to -- change only the pretty-printing, do some replumbing. See--- mkRoleAnnotDecl in RdrHsSyn+-- mkRoleAnnotDecl in GHC.Parser.PostProcess fsFromRole :: Role -> FastString fsFromRole Nominal          = fsLit "nominal" fsFromRole Representational = fsLit "representational"
compiler/GHC/Core/Coercion/Opt.hs view
@@ -6,23 +6,23 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Driver.Session import GHC.Core.TyCo.Rep import GHC.Core.TyCo.Subst import GHC.Core.Coercion import GHC.Core.Type as Type hiding( substTyVarBndr, substTy )-import TcType       ( exactTyCoVarsOfType )+import GHC.Tc.Utils.TcType   ( exactTyCoVarsOfType ) import GHC.Core.TyCon import GHC.Core.Coercion.Axiom import GHC.Types.Var.Set import GHC.Types.Var.Env-import Outputable+import GHC.Utils.Outputable import GHC.Core.FamInstEnv ( flattenTys )-import Pair-import ListSetOps ( getNth )-import Util+import GHC.Data.Pair+import GHC.Data.List.SetOps ( getNth )+import GHC.Utils.Misc import GHC.Core.Unify import GHC.Core.InstEnv import Control.Monad   ( zipWithM )@@ -559,8 +559,9 @@       PluginProv _       -> prov  --------------opt_transList :: InScopeSet -> [NormalCo] -> [NormalCo] -> [NormalCo]-opt_transList is = zipWith (opt_trans is)+opt_transList :: HasDebugCallStack => InScopeSet -> [NormalCo] -> [NormalCo] -> [NormalCo]+opt_transList is = zipWithEqual "opt_transList" (opt_trans is)+  -- The input lists must have identical length.  opt_trans :: InScopeSet -> NormalCo -> NormalCo -> NormalCo opt_trans is co1 co2@@ -659,14 +660,12 @@ -- Eta rules opt_trans_rule is co1@(TyConAppCo r tc cos1) co2   | Just cos2 <- etaTyConAppCo_maybe tc co2-  = ASSERT( cos1 `equalLength` cos2 )-    fireTransRule "EtaCompL" co1 co2 $+  = fireTransRule "EtaCompL" co1 co2 $     mkTyConAppCo r tc (opt_transList is cos1 cos2)  opt_trans_rule is co1 co2@(TyConAppCo r tc cos2)   | Just cos1 <- etaTyConAppCo_maybe tc co1-  = ASSERT( cos1 `equalLength` cos2 )-    fireTransRule "EtaCompR" co1 co2 $+  = fireTransRule "EtaCompR" co1 co2 $     mkTyConAppCo r tc (opt_transList is cos1 cos2)  opt_trans_rule is co1@(AppCo co1a co1b) co2
compiler/GHC/Core/ConLike.hs view
@@ -12,6 +12,7 @@         , conLikeArity         , conLikeFieldLabels         , conLikeInstOrigArgTys+        , conLikeUserTyVarBinders         , conLikeExTyCoVars         , conLikeName         , conLikeStupidTheta@@ -26,13 +27,13 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core.DataCon import GHC.Core.PatSyn-import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique-import Util+import GHC.Utils.Misc import GHC.Types.Name import GHC.Types.Basic import GHC.Core.TyCo.Rep (Type, ThetaType)@@ -112,6 +113,18 @@     dataConInstOrigArgTys data_con tys conLikeInstOrigArgTys (PatSynCon pat_syn) tys =     patSynInstArgTys pat_syn tys++-- | 'TyVarBinder's for the type variables of the 'ConLike'. For pattern+-- synonyms, this will always consist of the universally quantified variables+-- followed by the existentially quantified type variables. For data+-- constructors, the situation is slightly more complicated—see+-- @Note [DataCon user type variable binders]@ in "GHC.Core.DataCon".+conLikeUserTyVarBinders :: ConLike -> [TyVarBinder]+conLikeUserTyVarBinders (RealDataCon data_con) =+    dataConUserTyVarBinders data_con+conLikeUserTyVarBinders (PatSynCon pat_syn) =+    patSynUnivTyVarBinders pat_syn ++ patSynExTyVarBinders pat_syn+    -- The order here is because of the order in `GHC.Tc.TyCl.PatSyn`.  -- | Existentially quantified type/coercion variables conLikeExTyCoVars :: ConLike -> [TyCoVar]
compiler/GHC/Core/DataCon.hs view
@@ -61,7 +61,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Types.Id.Make ( DataConBoxer ) import GHC.Core.Type as Type@@ -71,15 +71,15 @@ import GHC.Types.FieldLabel import GHC.Core.Class import GHC.Types.Name-import PrelNames+import GHC.Builtin.Names import GHC.Core.Predicate import GHC.Types.Var-import Outputable-import Util+import GHC.Utils.Outputable+import GHC.Utils.Misc import GHC.Types.Basic-import FastString-import GHC.Types.Module-import Binary+import GHC.Data.FastString+import GHC.Unit+import GHC.Utils.Binary import GHC.Types.Unique.Set import GHC.Types.Unique( mkAlphaTyVarUnique ) @@ -298,7 +298,7 @@ -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen', --             'ApiAnnotation.AnnClose','ApiAnnotation.AnnComma' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data DataCon   = MkData {         dcName    :: Name,      -- This is the name of the *source data con*@@ -384,7 +384,9 @@                 --      MkT :: forall a b. (a ~ [b]) => b -> T a                 --      MkT :: forall b. b -> T [b]                 -- Each equality is of the form (a ~ ty), where 'a' is one of-                -- the universally quantified type variables+                -- the universally quantified type variables. Moreover, the+                -- only place in the DataCon where this 'a' will occur is in+                -- dcUnivTyVars. See [The dcEqSpec domain invariant].                  -- The next two fields give the type context of the data constructor                 --      (aside from the GADT constraints,@@ -595,6 +597,35 @@ the time. It's used when computing the type signature of a data constructor (see dataConUserType), and as a result, it's what matters from a TypeApplications perspective.++Note [The dcEqSpec domain invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this example of a GADT constructor:++  data Y a where+    MkY :: Bool -> Y Bool++The user-written type of MkY is `Bool -> Y Bool`, but what is the underlying+Core type for MkY? There are two conceivable possibilities:++1. MkY :: forall a. (a ~# Bool) => Bool -> Y a+2. MkY :: forall a. (a ~# Bool) => a    -> Y a++In practice, GHC picks (1) as the Core type for MkY. This is because we+maintain an invariant that the type variables in the domain of dcEqSpec will+only ever appear in the dcUnivTyVars. As a consequence, the type variables in+the domain of dcEqSpec will /never/ appear in the dcExTyCoVars, dcOtherTheta,+dcOrigArgTys, or dcOrigResTy; these can only ever mention variables from+dcUserTyVarBinders, which excludes things in the domain of dcEqSpec.+(See Note [DataCon user type variable binders].) This explains why GHC would+not pick (2) as the Core type, since the argument type `a` mentions a type+variable in the dcEqSpec.++There are certain parts of the codebase where it is convenient to apply the+substitution arising from the dcEqSpec to the dcUnivTyVars in order to obtain+the user-written return type of a GADT constructor. A consequence of the+dcEqSpec domain invariant is that you /never/ need to apply the substitution+to any other part of the constructor type, as they don't require it. -}  -- | Data Constructor Representation@@ -614,7 +645,7 @@                                  -- and *including* all evidence args          , dcr_stricts :: [StrictnessMark]  -- 1-1 with dcr_arg_tys-                -- See also Note [Data-con worker strictness] in GHC.Types.Id.Make+                -- See also Note [Data-con worker strictness]          , dcr_bangs :: [HsImplBang]  -- The actual decisions made (including failures)                                      -- about the original arguments; 1-1 with orig_arg_tys@@ -715,8 +746,26 @@ instance Outputable EqSpec where   ppr (EqSpec tv ty) = ppr (tv, ty) -{- Note [Bangs on data constructor arguments]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+{- Note [Data-con worker strictness]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Notice that we do *not* say the worker Id is strict even if the data+constructor is declared strict+     e.g.    data T = MkT !(Int,Int)+Why?  Because the *wrapper* $WMkT is strict (and its unfolding has case+expressions that do the evals) but the *worker* MkT itself is not. If we+pretend it is strict then when we see+     case x of y -> MkT y+the simplifier thinks that y is "sure to be evaluated" (because the worker MkT+is strict) and drops the case.  No, the workerId MkT is not strict.++However, the worker does have StrictnessMarks.  When the simplifier sees a+pattern+     case e of MkT x -> ...+it uses the dataConRepStrictness of MkT to mark x as evaluated; but that's+fine... dataConRepStrictness comes from the data con not from the worker Id.++Note [Bangs on data constructor arguments]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Consider   data T = MkT !Int {-# UNPACK #-} !Int Bool @@ -1342,7 +1391,7 @@ dataConIdentity :: DataCon -> ByteString -- We want this string to be UTF-8, so we get the bytes directly from the FastStrings. dataConIdentity dc = LBS.toStrict $ BSB.toLazyByteString $ mconcat-   [ BSB.byteString $ bytesFS (unitIdFS (moduleUnitId mod))+   [ BSB.byteString $ bytesFS (unitFS (moduleUnit mod))    , BSB.int8 $ fromIntegral (ord ':')    , BSB.byteString $ bytesFS (moduleNameFS (moduleName mod))    , BSB.int8 $ fromIntegral (ord '.')
compiler/GHC/Core/DataCon.hs-boot view
@@ -1,12 +1,12 @@ module GHC.Core.DataCon where -import GhcPrelude+import GHC.Prelude import GHC.Types.Var( TyVar, TyCoVar, TyVarBinder ) import GHC.Types.Name( Name, NamedThing ) import {-# SOURCE #-} GHC.Core.TyCon( TyCon ) import GHC.Types.FieldLabel ( FieldLabel ) import GHC.Types.Unique ( Uniquable )-import Outputable ( Outputable, OutputableBndr )+import GHC.Utils.Outputable ( Outputable, OutputableBndr ) import GHC.Types.Basic (Arity) import {-# SOURCE #-} GHC.Core.TyCo.Rep ( Type, ThetaType )
compiler/GHC/Core/FVs.hs view
@@ -35,7 +35,7 @@         idFVs,         idRuleVars, idRuleRhsVars, stableUnfoldingVars,         ruleRhsFreeVars, ruleFreeVars, rulesFreeVars,-        rulesFreeVarsDSet,+        rulesFreeVarsDSet, mkRuleInfo,         ruleLhsFreeIds, ruleLhsFreeIdsList,          expr_fvs,@@ -59,7 +59,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core import GHC.Types.Id@@ -76,12 +76,12 @@ import GHC.Core.TyCon import GHC.Core.Coercion.Axiom import GHC.Core.FamInstEnv-import TysPrim( funTyConName )-import Maybes( orElse )-import Util+import GHC.Builtin.Types.Prim( funTyConName )+import GHC.Data.Maybe( orElse )+import GHC.Utils.Misc import GHC.Types.Basic( Activation )-import Outputable-import FV+import GHC.Utils.Outputable+import GHC.Utils.FV as FV  {- ************************************************************************@@ -105,7 +105,7 @@ 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+-- returning a composable FV computation. See Note [FV naming conventions] in GHC.Utils.FV -- for why export it. exprFVs :: CoreExpr -> FV exprFVs = filterFV isLocalVar . expr_fvs@@ -150,7 +150,7 @@ 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+-- returning a composable FV computation. See Note [FV naming conventions] in GHC.Utils.FV -- for why export it. exprsFVs :: [CoreExpr] -> FV exprsFVs exprs = mapUnionFV exprFVs exprs@@ -468,6 +468,11 @@ -- returned as a deterministic set rulesFreeVarsDSet :: [CoreRule] -> DVarSet rulesFreeVarsDSet rules = fvDVarSet $ rulesFVs rules++-- | Make a 'RuleInfo' containing a number of 'CoreRule's, suitable+-- for putting into an 'IdInfo'+mkRuleInfo :: [CoreRule] -> RuleInfo+mkRuleInfo rules = RuleInfo rules (rulesFreeVarsDSet rules)  idRuleRhsVars :: (Activation -> Bool) -> Id -> VarSet -- Just the variables free on the *rhs* of a rule
compiler/GHC/Core/FamInstEnv.hs view
@@ -41,7 +41,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core.Unify import GHC.Core.Type as Type@@ -53,14 +53,14 @@ import GHC.Types.Var.Env import GHC.Types.Name import GHC.Types.Unique.DFM-import Outputable-import Maybes+import GHC.Utils.Outputable+import GHC.Data.Maybe import GHC.Core.Map import GHC.Types.Unique-import Util+import GHC.Utils.Misc import GHC.Types.Var import GHC.Types.SrcLoc-import FastString+import GHC.Data.FastString import Control.Monad import Data.List( mapAccumL ) import Data.Array( Array, assocs )@@ -118,6 +118,7 @@              , fi_tys    :: [Type]       --   The LHS type patterns             -- May be eta-reduced; see Note [Eta reduction for data families]+            -- in GHC.Core.Coercion.Axiom              , fi_rhs :: Type         --   the RHS, with its freshened vars             }@@ -132,7 +133,8 @@ Data family instances might legitimately be over- or under-saturated.  Under-saturation has two potential causes:- U1) Eta reduction. See Note [Eta reduction for data families].+ U1) Eta reduction. See Note [Eta reduction for data families] in+     GHC.Core.Coercion.Axiom.  U2) When the user has specified a return kind instead of written out patterns.      Example: @@ -160,8 +162,8 @@        However, we require that any over-saturation is eta-reducible. That is,       we require that any extra patterns be bare unrepeated type variables;-      see Note [Eta reduction for data families]. Accordingly, the FamInst-      is never over-saturated.+      see Note [Eta reduction for data families] in GHC.Core.Coercion.Axiom.+      Accordingly, the FamInst is never over-saturated.  Why can we allow such flexibility for data families but not for type families? Because data families can be decomposed -- that is, they are generative and@@ -314,7 +316,7 @@  - For finding overlaps and conflicts   - For finding the representation type...see FamInstEnv.topNormaliseType-   and its call site in GHC.Core.Op.Simplify+   and its call site in GHC.Core.Opt.Simplify   - In standalone deriving instance Eq (T [Int]) we need to find the    representation type for T [Int]@@ -335,7 +337,7 @@    axiom ax8 a :: T Bool [a] ~ TBoolList a  These two axioms for T, one with one pattern, one with two;-see Note [Eta reduction for data families]+see Note [Eta reduction for data families] in GHC.Core.Coercion.Axiom  Note [FamInstEnv determinism] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -479,7 +481,7 @@ Note [Compatibility of eta-reduced axioms] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In newtype instances of data families we eta-reduce the axioms,-See Note [Eta reduction for data families] in GHC.Core.FamInstEnv. This means that+See Note [Eta reduction for data families] in GHC.Core.Coercion.Axiom. This means that we sometimes need to test compatibility of two axioms that were eta-reduced to different degrees, e.g.: @@ -861,7 +863,7 @@        of last equation and check whether it is overlapped by any of previous        equations. Since it is overlapped by the first equation we conclude        that pair of last two equations does not violate injectivity-       annotation. (Check done in TcValidity.checkValidCoAxiom#gather_conflicts)+       annotation. (Check done in GHC.Tc.Validity.checkValidCoAxiom#gather_conflicts)     A special case of B is when RHSs unify with an empty substitution ie. they    are identical.@@ -896,7 +898,7 @@    injective.  "Injective position" means either an argument to a type    constructor or argument to a type family on injective position.    There are subtleties here. See Note [Coverage condition for injective type families]-   in FamInst.+   in GHC.Tc.Instance.Family.  Check (1) must be done for all family instances (transitively) imported. Other checks (2-4) should be done just for locally written equations, as they are checks@@ -1057,7 +1059,7 @@  * For data family instances, though, we need to re-split for each    instance, because the breakdown might be different for each    instance.  Why?  Because of eta reduction; see-   Note [Eta reduction for data families].+   Note [Eta reduction for data families] in GHC.Core.Coercion.Axiom. -}  -- checks if one LHS is dominated by a list of other branches@@ -1187,7 +1189,7 @@ apartnessCheck :: [Type]     -- ^ /flattened/ target arguments. Make sure                              -- they're flattened! See Note [Flattening].                              -- (NB: This "flat" is a different-                             -- "flat" than is used in TcFlatten.)+                             -- "flat" than is used in GHC.Tc.Solver.Flatten.)                -> CoAxBranch -- ^ the candidate equation we wish to use                              -- Precondition: this matches the target                -> Bool       -- ^ True <=> equation can fire@@ -1443,7 +1445,7 @@     go_app_tys :: Type   -- function                -> [Type] -- args                -> NormM (Coercion, Type)-    -- cf. TcFlatten.flatten_app_ty_args+    -- cf. GHC.Tc.Solver.Flatten.flatten_app_ty_args     go_app_tys (AppTy ty1 ty2) tys = go_app_tys ty1 (ty2 : tys)     go_app_tys fun_ty arg_tys       = do { (fun_co, nfun) <- go fun_ty@@ -1474,7 +1476,7 @@ -- and the res_co :: kind(f orig_args) ~ kind(f xis) -- NB: The xis might *not* have the same kinds as the input types, -- but the resulting application *will* be well-kinded--- cf. TcFlatten.flatten_args_slow+-- cf. GHC.Tc.Solver.Flatten.flatten_args_slow normalise_args fun_ki roles args   = do { normed_args <- zipWithM normalise1 roles args        ; let (xis, cos, res_co) = simplifyArgsWorker ki_binders inner_ki fvs roles normed_args
compiler/GHC/Core/InstEnv.hs view
@@ -4,7 +4,7 @@  \section[InstEnv]{Utilities for typechecking instance declarations} -The bits common to TcInstDcls and TcDeriv.+The bits common to GHC.Tc.TyCl.Instance and GHC.Tc.Deriv. -}  {-# LANGUAGE CPP, DeriveDataTypeable #-}@@ -31,23 +31,23 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import TcType -- InstEnv is really part of the type checker,+import GHC.Tc.Utils.TcType -- InstEnv is really part of the type checker,               -- and depends on TcType in many ways import GHC.Core ( IsOrphan(..), isOrphan, chooseOrphanAnchor )-import GHC.Types.Module+import GHC.Unit import GHC.Core.Class import GHC.Types.Var import GHC.Types.Var.Set import GHC.Types.Name import GHC.Types.Name.Set import GHC.Core.Unify-import Outputable-import ErrUtils+import GHC.Utils.Outputable+import GHC.Utils.Error import GHC.Types.Basic import GHC.Types.Unique.DFM-import Util+import GHC.Utils.Misc import GHC.Types.Id import Data.Data        ( Data ) import Data.Maybe       ( isJust, isNothing )@@ -453,7 +453,7 @@                 Nothing            -> []  -- | Checks for an exact match of ClsInst in the instance environment.--- We use this when we do signature checking in TcRnDriver+-- We use this when we do signature checking in GHC.Tc.Module memberInstEnv :: InstEnv -> ClsInst -> Bool memberInstEnv inst_env ins_item@(ClsInst { is_cls_nm = cls_nm } ) =     maybe False (\(ClsIE items) -> any (identicalDFunType ins_item) items)@@ -732,7 +732,7 @@        , [ClsInst]       -- These don't match but do unify        , [InstMatch] )   -- Unsafe overlapped instances under Safe Haskell                          -- (see Note [Safe Haskell Overlapping Instances] in-                         -- TcSimplify).+                         -- GHC.Tc.Solver).  {- Note [DFunInstType: instantiating types]@@ -835,8 +835,8 @@               -> Class -> [Type]   -- What we are looking for               -> ClsInstLookupResult -- ^ See Note [Rules for instance lookup]--- ^ See Note [Safe Haskell Overlapping Instances] in TcSimplify--- ^ See Note [Safe Haskell Overlapping Instances Implementation] in TcSimplify+-- ^ See Note [Safe Haskell Overlapping Instances] in GHC.Tc.Solver+-- ^ See Note [Safe Haskell Overlapping Instances Implementation] in GHC.Tc.Solver lookupInstEnv check_overlap_safe               (InstEnvs { ie_global = pkg_ie                         , ie_local = home_ie
compiler/GHC/Core/Make.hs view
@@ -54,7 +54,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Id import GHC.Types.Var  ( EvVar, setTyVarUnique )@@ -65,23 +65,23 @@ import GHC.Driver.Types import GHC.Platform -import TysWiredIn-import PrelNames+import GHC.Builtin.Types+import GHC.Builtin.Names  import GHC.Hs.Utils      ( mkChunkified, chunkify ) import GHC.Core.Type import GHC.Core.Coercion ( isCoVar ) import GHC.Core.DataCon  ( DataCon, dataConWorkId )-import TysPrim+import GHC.Builtin.Types.Prim import GHC.Types.Id.Info import GHC.Types.Demand import GHC.Types.Cpr import GHC.Types.Name      hiding ( varName )-import Outputable-import FastString+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Types.Unique.Supply import GHC.Types.Basic-import Util+import GHC.Utils.Misc import Data.List  import Data.Char        ( ord )@@ -192,7 +192,7 @@ -- 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 GHC.Core.Op.Simplify.Env+-- See Note [WildCard binders] in GHC.Core.Opt.Simplify.Env mkWildValBinder :: Type -> Id mkWildValBinder ty = mkLocalIdOrCoVar wildCardName ty   -- "OrCoVar" since a coercion can be a scrutinee with -fdefer-type-errors@@ -343,7 +343,7 @@ * Flatten it out, so that     mkCoreTup [e1] = e1 -* Build a one-tuple (see Note [One-tuples] in TysWiredIn)+* Build a one-tuple (see Note [One-tuples] in GHC.Builtin.Types)     mkCoreTup1 [e1] = Unit e1   We use a suffix "1" to indicate this. @@ -575,7 +575,7 @@   = FloatLet  CoreBind   | FloatCase CoreExpr Id AltCon [Var]       -- case e of y { C ys -> ... }-      -- See Note [Floating single-alternative cases] in GHC.Core.Op.SetLevels+      -- See Note [Floating single-alternative cases] in GHC.Core.Opt.SetLevels  instance Outputable FloatBind where   ppr (FloatLet b) = text "LET" <+> ppr b@@ -879,7 +879,7 @@    \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 GHC.Core.Op.WorkWrap) so the template ends up like+for INLINEABLE functions] in GHC.Core.Opt.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)@@ -924,7 +924,7 @@  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 GHC.Core.Op.WorkWrap.Lib+   -- lifted-type things; see Note [Absent errors] in GHC.Core.Opt.WorkWrap.Utils    arity_info = vanillaIdInfo `setArityInfo` 1    -- NB: no bottoming strictness info, unlike other error-ids.    -- See Note [aBSENT_ERROR_ID]
compiler/GHC/Core/Map.hs view
@@ -37,23 +37,23 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import TrieMap+import GHC.Data.TrieMap import GHC.Core import GHC.Core.Coercion import GHC.Types.Name import GHC.Core.Type import GHC.Core.TyCo.Rep import GHC.Types.Var-import FastString(FastString)-import Util+import GHC.Data.FastString(FastString)+import GHC.Utils.Misc  import qualified Data.Map    as Map import qualified Data.IntMap as IntMap import GHC.Types.Var.Env import GHC.Types.Name.Env-import Outputable+import GHC.Utils.Outputable import Control.Monad( (>=>) )  {-
− compiler/GHC/Core/Op/ConstantFold.hs 
@@ -1,2254 +0,0 @@-{--(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[ConFold]{Constant Folder}--Conceptually, constant folding should be parameterized with the kind-of target machine to get identical behaviour during compilation time-and runtime. We cheat a little bit here...--ToDo:-   check boundaries before folding, e.g. we can fold the Float addition-   (i1 + i2) only if it results in a valid Float.--}--{-# LANGUAGE CPP, RankNTypes, PatternSynonyms, ViewPatterns, RecordWildCards,-    DeriveFunctor #-}-{-# LANGUAGE LambdaCase #-}-{-# OPTIONS_GHC -optc-DNON_POSIX_SOURCE -Wno-incomplete-uni-patterns #-}--module GHC.Core.Op.ConstantFold-   ( primOpRules-   , builtinRules-   , caseRules-   )-where--#include "HsVersions.h"--import GhcPrelude--import {-# SOURCE #-} GHC.Types.Id.Make ( mkPrimOpId, magicDictId )--import GHC.Core-import GHC.Core.Make-import GHC.Types.Id-import GHC.Types.Literal-import GHC.Core.SimpleOpt ( exprIsLiteral_maybe )-import PrimOp             ( PrimOp(..), tagToEnumKey )-import TysWiredIn-import TysPrim-import GHC.Core.TyCon-   ( tyConDataCons_maybe, isAlgTyCon, isEnumerationTyCon-   , isNewTyCon, unwrapNewTyCon_maybe, tyConDataCons-   , tyConFamilySize )-import GHC.Core.DataCon ( dataConTagZ, dataConTyCon, dataConWrapId, dataConWorkId )-import GHC.Core.Utils  ( cheapEqExpr, cheapEqExpr', exprIsHNF, exprType-                       , stripTicksTop, stripTicksTopT, mkTicks )-import GHC.Core.Unfold ( exprIsConApp_maybe )-import GHC.Core.Type-import GHC.Types.Name.Occurrence ( occNameFS )-import PrelNames-import Maybes      ( orElse )-import GHC.Types.Name ( Name, nameOccName )-import Outputable-import FastString-import GHC.Types.Basic-import GHC.Platform-import Util-import GHC.Core.Coercion   (mkUnbranchedAxInstCo,mkSymCo,Role(..))--import Control.Applicative ( Alternative(..) )--import Control.Monad-import Data.Bits as Bits-import qualified Data.ByteString as BS-import Data.Int-import Data.Ratio-import Data.Word--{--Note [Constant folding]-~~~~~~~~~~~~~~~~~~~~~~~-primOpRules generates a rewrite rule for each primop-These rules do what is often called "constant folding"-E.g. the rules for +# might say-        4 +# 5 = 9-Well, of course you'd need a lot of rules if you did it-like that, so we use a BuiltinRule instead, so that we-can match in any two literal values.  So the rule is really-more like-        (Lit x) +# (Lit y) = Lit (x+#y)-where the (+#) on the rhs is done at compile time--That is why these rules are built in here.--}--primOpRules ::  Name -> PrimOp -> Maybe CoreRule-primOpRules nm = \case-   TagToEnumOp -> mkPrimOpRule nm 2 [ tagToEnumRule ]-   DataToTagOp -> mkPrimOpRule nm 2 [ dataToTagRule ]--   -- Int operations-   IntAddOp    -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (+))-                                    , identityPlatform zeroi-                                    , numFoldingRules IntAddOp intPrimOps-                                    ]-   IntSubOp    -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (-))-                                    , rightIdentityPlatform zeroi-                                    , equalArgs >> retLit zeroi-                                    , numFoldingRules IntSubOp intPrimOps-                                    ]-   IntAddCOp   -> mkPrimOpRule nm 2 [ binaryLit (intOpC2 (+))-                                    , identityCPlatform zeroi ]-   IntSubCOp   -> mkPrimOpRule nm 2 [ binaryLit (intOpC2 (-))-                                    , rightIdentityCPlatform zeroi-                                    , equalArgs >> retLitNoC zeroi ]-   IntMulOp    -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (*))-                                    , zeroElem zeroi-                                    , identityPlatform onei-                                    , numFoldingRules IntMulOp intPrimOps-                                    ]-   IntQuotOp   -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (intOp2 quot)-                                    , leftZero zeroi-                                    , rightIdentityPlatform onei-                                    , equalArgs >> retLit onei ]-   IntRemOp    -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (intOp2 rem)-                                    , leftZero zeroi-                                    , do l <- getLiteral 1-                                         platform <- getPlatform-                                         guard (l == onei platform)-                                         retLit zeroi-                                    , equalArgs >> retLit zeroi-                                    , equalArgs >> retLit zeroi ]-   AndIOp      -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (.&.))-                                    , idempotent-                                    , zeroElem zeroi ]-   OrIOp       -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (.|.))-                                    , idempotent-                                    , identityPlatform zeroi ]-   XorIOp      -> mkPrimOpRule nm 2 [ binaryLit (intOp2 xor)-                                    , identityPlatform zeroi-                                    , equalArgs >> retLit zeroi ]-   NotIOp      -> mkPrimOpRule nm 1 [ unaryLit complementOp-                                    , inversePrimOp NotIOp ]-   IntNegOp    -> mkPrimOpRule nm 1 [ unaryLit negOp-                                    , inversePrimOp IntNegOp ]-   ISllOp      -> mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftL)-                                    , rightIdentityPlatform zeroi ]-   ISraOp      -> mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftR)-                                    , rightIdentityPlatform zeroi ]-   ISrlOp      -> mkPrimOpRule nm 2 [ shiftRule shiftRightLogical-                                    , rightIdentityPlatform zeroi ]--   -- Word operations-   WordAddOp   -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (+))-                                    , identityPlatform zerow-                                    , numFoldingRules WordAddOp wordPrimOps-                                    ]-   WordSubOp   -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (-))-                                    , rightIdentityPlatform zerow-                                    , equalArgs >> retLit zerow-                                    , numFoldingRules WordSubOp wordPrimOps-                                    ]-   WordAddCOp  -> mkPrimOpRule nm 2 [ binaryLit (wordOpC2 (+))-                                    , identityCPlatform zerow ]-   WordSubCOp  -> mkPrimOpRule nm 2 [ binaryLit (wordOpC2 (-))-                                    , rightIdentityCPlatform zerow-                                    , equalArgs >> retLitNoC zerow ]-   WordMulOp   -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (*))-                                    , identityPlatform onew-                                    , numFoldingRules WordMulOp wordPrimOps-                                    ]-   WordQuotOp  -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (wordOp2 quot)-                                    , rightIdentityPlatform onew ]-   WordRemOp   -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (wordOp2 rem)-                                    , leftZero zerow-                                    , do l <- getLiteral 1-                                         platform <- getPlatform-                                         guard (l == onew platform)-                                         retLit zerow-                                    , equalArgs >> retLit zerow ]-   AndOp       -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (.&.))-                                    , idempotent-                                    , zeroElem zerow ]-   OrOp        -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (.|.))-                                    , idempotent-                                    , identityPlatform zerow ]-   XorOp       -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 xor)-                                    , identityPlatform zerow-                                    , equalArgs >> retLit zerow ]-   NotOp       -> mkPrimOpRule nm 1 [ unaryLit complementOp-                                    , inversePrimOp NotOp ]-   SllOp       -> mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftL) ]-   SrlOp       -> mkPrimOpRule nm 2 [ shiftRule shiftRightLogical ]--   -- coercions-   Word2IntOp     -> mkPrimOpRule nm 1 [ liftLitPlatform word2IntLit-                                       , inversePrimOp Int2WordOp ]-   Int2WordOp     -> mkPrimOpRule nm 1 [ liftLitPlatform int2WordLit-                                       , inversePrimOp Word2IntOp ]-   Narrow8IntOp   -> mkPrimOpRule nm 1 [ liftLit narrow8IntLit-                                       , subsumedByPrimOp Narrow8IntOp-                                       , Narrow8IntOp `subsumesPrimOp` Narrow16IntOp-                                       , Narrow8IntOp `subsumesPrimOp` Narrow32IntOp-                                       , narrowSubsumesAnd AndIOp Narrow8IntOp 8 ]-   Narrow16IntOp  -> mkPrimOpRule nm 1 [ liftLit narrow16IntLit-                                       , subsumedByPrimOp Narrow8IntOp-                                       , subsumedByPrimOp Narrow16IntOp-                                       , Narrow16IntOp `subsumesPrimOp` Narrow32IntOp-                                       , narrowSubsumesAnd AndIOp Narrow16IntOp 16 ]-   Narrow32IntOp  -> mkPrimOpRule nm 1 [ liftLit narrow32IntLit-                                       , subsumedByPrimOp Narrow8IntOp-                                       , subsumedByPrimOp Narrow16IntOp-                                       , subsumedByPrimOp Narrow32IntOp-                                       , removeOp32-                                       , narrowSubsumesAnd AndIOp Narrow32IntOp 32 ]-   Narrow8WordOp  -> mkPrimOpRule nm 1 [ liftLit narrow8WordLit-                                       , subsumedByPrimOp Narrow8WordOp-                                       , Narrow8WordOp `subsumesPrimOp` Narrow16WordOp-                                       , Narrow8WordOp `subsumesPrimOp` Narrow32WordOp-                                       , narrowSubsumesAnd AndOp Narrow8WordOp 8 ]-   Narrow16WordOp -> mkPrimOpRule nm 1 [ liftLit narrow16WordLit-                                       , subsumedByPrimOp Narrow8WordOp-                                       , subsumedByPrimOp Narrow16WordOp-                                       , Narrow16WordOp `subsumesPrimOp` Narrow32WordOp-                                       , narrowSubsumesAnd AndOp Narrow16WordOp 16 ]-   Narrow32WordOp -> mkPrimOpRule nm 1 [ liftLit narrow32WordLit-                                       , subsumedByPrimOp Narrow8WordOp-                                       , subsumedByPrimOp Narrow16WordOp-                                       , subsumedByPrimOp Narrow32WordOp-                                       , removeOp32-                                       , narrowSubsumesAnd AndOp Narrow32WordOp 32 ]-   OrdOp          -> mkPrimOpRule nm 1 [ liftLit char2IntLit-                                       , inversePrimOp ChrOp ]-   ChrOp          -> mkPrimOpRule nm 1 [ do [Lit lit] <- getArgs-                                            guard (litFitsInChar lit)-                                            liftLit int2CharLit-                                       , inversePrimOp OrdOp ]-   Float2IntOp    -> mkPrimOpRule nm 1 [ liftLit float2IntLit ]-   Int2FloatOp    -> mkPrimOpRule nm 1 [ liftLit int2FloatLit ]-   Double2IntOp   -> mkPrimOpRule nm 1 [ liftLit double2IntLit ]-   Int2DoubleOp   -> mkPrimOpRule nm 1 [ liftLit int2DoubleLit ]-   -- SUP: Not sure what the standard says about precision in the following 2 cases-   Float2DoubleOp -> mkPrimOpRule nm 1 [ liftLit float2DoubleLit ]-   Double2FloatOp -> mkPrimOpRule nm 1 [ liftLit double2FloatLit ]--   -- Float-   FloatAddOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (+))-                                     , identity zerof ]-   FloatSubOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (-))-                                     , rightIdentity zerof ]-   FloatMulOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (*))-                                     , identity onef-                                     , strengthReduction twof FloatAddOp  ]-             -- zeroElem zerof doesn't hold because of NaN-   FloatDivOp   -> mkPrimOpRule nm 2 [ guardFloatDiv >> binaryLit (floatOp2 (/))-                                     , rightIdentity onef ]-   FloatNegOp   -> mkPrimOpRule nm 1 [ unaryLit negOp-                                     , inversePrimOp FloatNegOp ]--   -- Double-   DoubleAddOp   -> mkPrimOpRule nm 2 [ binaryLit (doubleOp2 (+))-                                      , identity zerod ]-   DoubleSubOp   -> mkPrimOpRule nm 2 [ binaryLit (doubleOp2 (-))-                                      , rightIdentity zerod ]-   DoubleMulOp   -> mkPrimOpRule nm 2 [ binaryLit (doubleOp2 (*))-                                      , identity oned-                                      , strengthReduction twod DoubleAddOp  ]-              -- zeroElem zerod doesn't hold because of NaN-   DoubleDivOp   -> mkPrimOpRule nm 2 [ guardDoubleDiv >> binaryLit (doubleOp2 (/))-                                      , rightIdentity oned ]-   DoubleNegOp   -> mkPrimOpRule nm 1 [ unaryLit negOp-                                      , inversePrimOp DoubleNegOp ]--   -- Relational operators--   IntEqOp    -> mkRelOpRule nm (==) [ litEq True ]-   IntNeOp    -> mkRelOpRule nm (/=) [ litEq False ]-   CharEqOp   -> mkRelOpRule nm (==) [ litEq True ]-   CharNeOp   -> mkRelOpRule nm (/=) [ litEq False ]--   IntGtOp    -> mkRelOpRule nm (>)  [ boundsCmp Gt ]-   IntGeOp    -> mkRelOpRule nm (>=) [ boundsCmp Ge ]-   IntLeOp    -> mkRelOpRule nm (<=) [ boundsCmp Le ]-   IntLtOp    -> mkRelOpRule nm (<)  [ boundsCmp Lt ]--   CharGtOp   -> mkRelOpRule nm (>)  [ boundsCmp Gt ]-   CharGeOp   -> mkRelOpRule nm (>=) [ boundsCmp Ge ]-   CharLeOp   -> mkRelOpRule nm (<=) [ boundsCmp Le ]-   CharLtOp   -> mkRelOpRule nm (<)  [ boundsCmp Lt ]--   FloatGtOp  -> mkFloatingRelOpRule nm (>)-   FloatGeOp  -> mkFloatingRelOpRule nm (>=)-   FloatLeOp  -> mkFloatingRelOpRule nm (<=)-   FloatLtOp  -> mkFloatingRelOpRule nm (<)-   FloatEqOp  -> mkFloatingRelOpRule nm (==)-   FloatNeOp  -> mkFloatingRelOpRule nm (/=)--   DoubleGtOp -> mkFloatingRelOpRule nm (>)-   DoubleGeOp -> mkFloatingRelOpRule nm (>=)-   DoubleLeOp -> mkFloatingRelOpRule nm (<=)-   DoubleLtOp -> mkFloatingRelOpRule nm (<)-   DoubleEqOp -> mkFloatingRelOpRule nm (==)-   DoubleNeOp -> mkFloatingRelOpRule nm (/=)--   WordGtOp   -> mkRelOpRule nm (>)  [ boundsCmp Gt ]-   WordGeOp   -> mkRelOpRule nm (>=) [ boundsCmp Ge ]-   WordLeOp   -> mkRelOpRule nm (<=) [ boundsCmp Le ]-   WordLtOp   -> mkRelOpRule nm (<)  [ boundsCmp Lt ]-   WordEqOp   -> mkRelOpRule nm (==) [ litEq True ]-   WordNeOp   -> mkRelOpRule nm (/=) [ litEq False ]--   AddrAddOp  -> mkPrimOpRule nm 2 [ rightIdentityPlatform zeroi ]--   SeqOp      -> mkPrimOpRule nm 4 [ seqRule ]-   SparkOp    -> mkPrimOpRule nm 4 [ sparkRule ]--   _          -> Nothing--{--************************************************************************-*                                                                      *-\subsection{Doing the business}-*                                                                      *-************************************************************************--}---- useful shorthands-mkPrimOpRule :: Name -> Int -> [RuleM CoreExpr] -> Maybe CoreRule-mkPrimOpRule nm arity rules = Just $ mkBasicRule nm arity (msum rules)--mkRelOpRule :: Name -> (forall a . Ord a => a -> a -> Bool)-            -> [RuleM CoreExpr] -> Maybe CoreRule-mkRelOpRule nm cmp extra-  = mkPrimOpRule nm 2 $-    binaryCmpLit cmp : equal_rule : extra-  where-        -- x `cmp` x does not depend on x, so-        -- compute it for the arbitrary value 'True'-        -- and use that result-    equal_rule = do { equalArgs-                    ; platform <- getPlatform-                    ; return (if cmp True True-                              then trueValInt  platform-                              else falseValInt platform) }--{- Note [Rules for floating-point comparisons]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We need different rules for floating-point values because for floats-it is not true that x = x (for NaNs); so we do not want the equal_rule-rule that mkRelOpRule uses.--Note also that, in the case of equality/inequality, we do /not/-want to switch to a case-expression.  For example, we do not want-to convert-   case (eqFloat# x 3.8#) of-     True -> this-     False -> that-to-  case x of-    3.8#::Float# -> this-    _            -> that-See #9238.  Reason: comparing floating-point values for equality-delicate, and we don't want to implement that delicacy in the code for-case expressions.  So we make it an invariant of Core that a case-expression never scrutinises a Float# or Double#.--This transformation is what the litEq rule does;-see Note [The litEq rule: converting equality to case].-So we /refrain/ from using litEq for mkFloatingRelOpRule.--}--mkFloatingRelOpRule :: Name -> (forall a . Ord a => a -> a -> Bool)-                    -> Maybe CoreRule--- See Note [Rules for floating-point comparisons]-mkFloatingRelOpRule nm cmp-  = mkPrimOpRule nm 2 [binaryCmpLit cmp]---- common constants-zeroi, onei, zerow, onew :: Platform -> Literal-zeroi platform = mkLitInt  platform 0-onei  platform = mkLitInt  platform 1-zerow platform = mkLitWord platform 0-onew  platform = mkLitWord platform 1--zerof, onef, twof, zerod, oned, twod :: Literal-zerof = mkLitFloat 0.0-onef  = mkLitFloat 1.0-twof  = mkLitFloat 2.0-zerod = mkLitDouble 0.0-oned  = mkLitDouble 1.0-twod  = mkLitDouble 2.0--cmpOp :: Platform -> (forall a . Ord a => a -> a -> Bool)-      -> Literal -> Literal -> Maybe CoreExpr-cmpOp platform cmp = go-  where-    done True  = Just $ trueValInt  platform-    done False = Just $ falseValInt platform--    -- These compares are at different types-    go (LitChar i1)   (LitChar i2)   = done (i1 `cmp` i2)-    go (LitFloat i1)  (LitFloat i2)  = done (i1 `cmp` i2)-    go (LitDouble i1) (LitDouble i2) = done (i1 `cmp` i2)-    go (LitNumber nt1 i1 _) (LitNumber nt2 i2 _)-      | nt1 /= nt2 = Nothing-      | otherwise  = done (i1 `cmp` i2)-    go _               _               = Nothing------------------------------negOp :: RuleOpts -> Literal -> Maybe CoreExpr  -- Negate-negOp env = \case-   (LitFloat 0.0)  -> Nothing  -- can't represent -0.0 as a Rational-   (LitFloat f)    -> Just (mkFloatVal env (-f))-   (LitDouble 0.0) -> Nothing-   (LitDouble d)   -> Just (mkDoubleVal env (-d))-   (LitNumber nt i t)-      | litNumIsSigned nt -> Just (Lit (mkLitNumberWrap (roPlatform env) nt (-i) t))-   _ -> Nothing--complementOp :: RuleOpts -> Literal -> Maybe CoreExpr  -- Binary complement-complementOp env (LitNumber nt i t) =-   Just (Lit (mkLitNumberWrap (roPlatform env) nt (complement i) t))-complementOp _      _            = Nothing-----------------------------intOp2 :: (Integral a, Integral b)-       => (a -> b -> Integer)-       -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr-intOp2 = intOp2' . const--intOp2' :: (Integral a, Integral b)-        => (RuleOpts -> a -> b -> Integer)-        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr-intOp2' op env (LitNumber LitNumInt i1 _) (LitNumber LitNumInt i2 _) =-  let o = op env-  in  intResult (roPlatform env) (fromInteger i1 `o` fromInteger i2)-intOp2' _  _      _            _            = Nothing  -- Could find LitLit--intOpC2 :: (Integral a, Integral b)-        => (a -> b -> Integer)-        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr-intOpC2 op env (LitNumber LitNumInt i1 _) (LitNumber LitNumInt i2 _) = do-  intCResult (roPlatform env) (fromInteger i1 `op` fromInteger i2)-intOpC2 _  _      _            _            = Nothing  -- Could find LitLit--shiftRightLogical :: Platform -> Integer -> Int -> Integer--- Shift right, putting zeros in rather than sign-propagating as Bits.shiftR would do--- Do this by converting to Word and back.  Obviously this won't work for big--- values, but its ok as we use it here-shiftRightLogical platform x n =-    case platformWordSize platform of-      PW4 -> fromIntegral (fromInteger x `shiftR` n :: Word32)-      PW8 -> fromIntegral (fromInteger x `shiftR` n :: Word64)-----------------------------retLit :: (Platform -> Literal) -> RuleM CoreExpr-retLit l = do platform <- getPlatform-              return $ Lit $ l platform--retLitNoC :: (Platform -> Literal) -> RuleM CoreExpr-retLitNoC l = do platform <- getPlatform-                 let lit = l platform-                 let ty = literalType lit-                 return $ mkCoreUbxTup [ty, ty] [Lit lit, Lit (zeroi platform)]--wordOp2 :: (Integral a, Integral b)-        => (a -> b -> Integer)-        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr-wordOp2 op env (LitNumber LitNumWord w1 _) (LitNumber LitNumWord w2 _)-    = wordResult (roPlatform env) (fromInteger w1 `op` fromInteger w2)-wordOp2 _ _ _ _ = Nothing  -- Could find LitLit--wordOpC2 :: (Integral a, Integral b)-        => (a -> b -> Integer)-        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr-wordOpC2 op env (LitNumber LitNumWord w1 _) (LitNumber LitNumWord w2 _) =-  wordCResult (roPlatform env) (fromInteger w1 `op` fromInteger w2)-wordOpC2 _ _ _ _ = Nothing  -- Could find LitLit--shiftRule :: (Platform -> Integer -> Int -> Integer) -> RuleM CoreExpr--- Shifts take an Int; hence third arg of op is Int--- Used for shift primops---    ISllOp, ISraOp, ISrlOp :: Word# -> Int# -> Word#---    SllOp, SrlOp           :: Word# -> Int# -> Word#-shiftRule shift_op-  = do { platform <- getPlatform-       ; [e1, Lit (LitNumber LitNumInt shift_len _)] <- getArgs-       ; case e1 of-           _ | shift_len == 0-             -> return e1-             -- See Note [Guarding against silly shifts]-             | shift_len < 0 || shift_len > toInteger (platformWordSizeInBits platform)-             -> return $ Lit $ mkLitNumberWrap platform LitNumInt 0 (exprType e1)--           -- Do the shift at type Integer, but shift length is Int-           Lit (LitNumber nt x t)-             | 0 < shift_len-             , shift_len <= toInteger (platformWordSizeInBits platform)-             -> let op = shift_op platform-                    y  = x `op` fromInteger shift_len-                in  liftMaybe $ Just (Lit (mkLitNumberWrap platform nt y t))--           _ -> mzero }-----------------------------floatOp2 :: (Rational -> Rational -> Rational)-         -> RuleOpts -> Literal -> Literal-         -> Maybe (Expr CoreBndr)-floatOp2 op env (LitFloat f1) (LitFloat f2)-  = Just (mkFloatVal env (f1 `op` f2))-floatOp2 _ _ _ _ = Nothing-----------------------------doubleOp2 :: (Rational -> Rational -> Rational)-          -> RuleOpts -> Literal -> Literal-          -> Maybe (Expr CoreBndr)-doubleOp2 op env (LitDouble f1) (LitDouble f2)-  = Just (mkDoubleVal env (f1 `op` f2))-doubleOp2 _ _ _ _ = Nothing-----------------------------{- Note [The litEq rule: converting equality to case]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-This stuff turns-     n ==# 3#-into-     case n of-       3# -> True-       m  -> False--This is a Good Thing, because it allows case-of case things-to happen, and case-default absorption to happen.  For-example:--     if (n ==# 3#) || (n ==# 4#) then e1 else e2-will transform to-     case n of-       3# -> e1-       4# -> e1-       m  -> e2-(modulo the usual precautions to avoid duplicating e1)--}--litEq :: Bool  -- True <=> equality, False <=> inequality-      -> RuleM CoreExpr-litEq is_eq = msum-  [ do [Lit lit, expr] <- getArgs-       platform <- getPlatform-       do_lit_eq platform lit expr-  , do [expr, Lit lit] <- getArgs-       platform <- getPlatform-       do_lit_eq platform lit expr ]-  where-    do_lit_eq platform lit expr = do-      guard (not (litIsLifted lit))-      return (mkWildCase expr (literalType lit) intPrimTy-                    [(DEFAULT,    [], val_if_neq),-                     (LitAlt lit, [], val_if_eq)])-      where-        val_if_eq  | is_eq     = trueValInt  platform-                   | otherwise = falseValInt platform-        val_if_neq | is_eq     = falseValInt platform-                   | otherwise = trueValInt  platform----- | Check if there is comparison with minBound or maxBound, that is--- always true or false. For instance, an Int cannot be smaller than its--- minBound, so we can replace such comparison with False.-boundsCmp :: Comparison -> RuleM CoreExpr-boundsCmp op = do-  platform <- getPlatform-  [a, b] <- getArgs-  liftMaybe $ mkRuleFn platform op a b--data Comparison = Gt | Ge | Lt | Le--mkRuleFn :: Platform -> Comparison -> CoreExpr -> CoreExpr -> Maybe CoreExpr-mkRuleFn platform Gt (Lit lit) _ | isMinBound platform lit = Just $ falseValInt platform-mkRuleFn platform Le (Lit lit) _ | isMinBound platform lit = Just $ trueValInt  platform-mkRuleFn platform Ge _ (Lit lit) | isMinBound platform lit = Just $ trueValInt  platform-mkRuleFn platform Lt _ (Lit lit) | isMinBound platform lit = Just $ falseValInt platform-mkRuleFn platform Ge (Lit lit) _ | isMaxBound platform lit = Just $ trueValInt  platform-mkRuleFn platform Lt (Lit lit) _ | isMaxBound platform lit = Just $ falseValInt platform-mkRuleFn platform Gt _ (Lit lit) | isMaxBound platform lit = Just $ falseValInt platform-mkRuleFn platform Le _ (Lit lit) | isMaxBound platform lit = Just $ trueValInt  platform-mkRuleFn _ _ _ _                                           = Nothing--isMinBound :: Platform -> Literal -> Bool-isMinBound _        (LitChar c)        = c == minBound-isMinBound platform (LitNumber nt i _) = case nt of-   LitNumInt     -> i == platformMinInt platform-   LitNumInt64   -> i == toInteger (minBound :: Int64)-   LitNumWord    -> i == 0-   LitNumWord64  -> i == 0-   LitNumNatural -> i == 0-   LitNumInteger -> False-isMinBound _        _                  = False--isMaxBound :: Platform -> Literal -> Bool-isMaxBound _        (LitChar c)        = c == maxBound-isMaxBound platform (LitNumber nt i _) = case nt of-   LitNumInt     -> i == platformMaxInt platform-   LitNumInt64   -> i == toInteger (maxBound :: Int64)-   LitNumWord    -> i == platformMaxWord platform-   LitNumWord64  -> i == toInteger (maxBound :: Word64)-   LitNumNatural -> False-   LitNumInteger -> False-isMaxBound _        _                  = False---- | Create an Int literal expression while ensuring the given Integer is in the--- target Int range-intResult :: Platform -> Integer -> Maybe CoreExpr-intResult platform result = Just (intResult' platform result)--intResult' :: Platform -> Integer -> CoreExpr-intResult' platform result = Lit (mkLitIntWrap platform result)---- | Create an unboxed pair of an Int literal expression, ensuring the given--- Integer is in the target Int range and the corresponding overflow flag--- (@0#@/@1#@) if it wasn't.-intCResult :: Platform -> Integer -> Maybe CoreExpr-intCResult platform result = Just (mkPair [Lit lit, Lit c])-  where-    mkPair = mkCoreUbxTup [intPrimTy, intPrimTy]-    (lit, b) = mkLitIntWrapC platform result-    c = if b then onei platform else zeroi platform---- | Create a Word literal expression while ensuring the given Integer is in the--- target Word range-wordResult :: Platform -> Integer -> Maybe CoreExpr-wordResult platform result = Just (wordResult' platform result)--wordResult' :: Platform -> Integer -> CoreExpr-wordResult' platform result = Lit (mkLitWordWrap platform result)---- | Create an unboxed pair of a Word literal expression, ensuring the given--- Integer is in the target Word range and the corresponding carry flag--- (@0#@/@1#@) if it wasn't.-wordCResult :: Platform -> Integer -> Maybe CoreExpr-wordCResult platform result = Just (mkPair [Lit lit, Lit c])-  where-    mkPair = mkCoreUbxTup [wordPrimTy, intPrimTy]-    (lit, b) = mkLitWordWrapC platform result-    c = if b then onei platform else zeroi platform--inversePrimOp :: PrimOp -> RuleM CoreExpr-inversePrimOp primop = do-  [Var primop_id `App` e] <- getArgs-  matchPrimOpId primop primop_id-  return e--subsumesPrimOp :: PrimOp -> PrimOp -> RuleM CoreExpr-this `subsumesPrimOp` that = do-  [Var primop_id `App` e] <- getArgs-  matchPrimOpId that primop_id-  return (Var (mkPrimOpId this) `App` e)--subsumedByPrimOp :: PrimOp -> RuleM CoreExpr-subsumedByPrimOp primop = do-  [e@(Var primop_id `App` _)] <- getArgs-  matchPrimOpId primop primop_id-  return e---- | narrow subsumes bitwise `and` with full mask (cf #16402):------       narrowN (x .&. m)---       m .&. (2^N-1) = 2^N-1---       ==> narrowN x------ e.g.  narrow16 (x .&. 0xFFFF)---       ==> narrow16 x----narrowSubsumesAnd :: PrimOp -> PrimOp -> Int -> RuleM CoreExpr-narrowSubsumesAnd and_primop narrw n = do-  [Var primop_id `App` x `App` y] <- getArgs-  matchPrimOpId and_primop primop_id-  let mask = bit n -1-      g v (Lit (LitNumber _ m _)) = do-         guard (m .&. mask == mask)-         return (Var (mkPrimOpId narrw) `App` v)-      g _ _ = mzero-  g x y <|> g y x--idempotent :: RuleM CoreExpr-idempotent = do [e1, e2] <- getArgs-                guard $ cheapEqExpr e1 e2-                return e1--{--Note [Guarding against silly shifts]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this code:--  import Data.Bits( (.|.), shiftL )-  chunkToBitmap :: [Bool] -> Word32-  chunkToBitmap chunk = foldr (.|.) 0 [ 1 `shiftL` n | (True,n) <- zip chunk [0..] ]--This optimises to:-Shift.$wgo = \ (w_sCS :: GHC.Prim.Int#) (w1_sCT :: [GHC.Types.Bool]) ->-    case w1_sCT of _ {-      [] -> 0##;-      : x_aAW xs_aAX ->-        case x_aAW of _ {-          GHC.Types.False ->-            case w_sCS of wild2_Xh {-              __DEFAULT -> Shift.$wgo (GHC.Prim.+# wild2_Xh 1) xs_aAX;-              9223372036854775807 -> 0## };-          GHC.Types.True ->-            case GHC.Prim.>=# w_sCS 64 of _ {-              GHC.Types.False ->-                case w_sCS of wild3_Xh {-                  __DEFAULT ->-                    case Shift.$wgo (GHC.Prim.+# wild3_Xh 1) xs_aAX of ww_sCW { __DEFAULT ->-                      GHC.Prim.or# (GHC.Prim.narrow32Word#-                                      (GHC.Prim.uncheckedShiftL# 1## wild3_Xh))-                                   ww_sCW-                     };-                  9223372036854775807 ->-                    GHC.Prim.narrow32Word#-!!!!-->                  (GHC.Prim.uncheckedShiftL# 1## 9223372036854775807)-                };-              GHC.Types.True ->-                case w_sCS of wild3_Xh {-                  __DEFAULT -> Shift.$wgo (GHC.Prim.+# wild3_Xh 1) xs_aAX;-                  9223372036854775807 -> 0##-                } } } }--Note the massive shift on line "!!!!".  It can't happen, because we've checked-that w < 64, but the optimiser didn't spot that. We DO NOT want to constant-fold this!-Moreover, if the programmer writes (n `uncheckedShiftL` 9223372036854775807), we-can't constant fold it, but if it gets to the assembler we get-     Error: operand type mismatch for `shl'--So the best thing to do is to rewrite the shift with a call to error,-when the second arg is large. However, in general we cannot do this; consider-this case--    let x = I# (uncheckedIShiftL# n 80)-    in ...--Here x contains an invalid shift and consequently we would like to rewrite it-as follows:--    let x = I# (error "invalid shift)-    in ...--This was originally done in the fix to #16449 but this breaks the let/app-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.--Consequently we instead take advantage of the fact that large shifts are-undefined behavior (see associated documentation in primops.txt.pp) and-transform the invalid shift into an "obviously incorrect" value.--There are two cases:--- Shifting fixed-width things: the primops ISll, Sll, etc-  These are handled by shiftRule.--  We are happy to shift by any amount up to wordSize but no more.--- Shifting Integers: the function shiftLInteger, shiftRInteger-  from the 'integer' library.   These are handled by rule_shift_op,-  and match_Integer_shift_op.--  Here we could in principle shift by any amount, but we arbitrary-  limit the shift to 4 bits; in particular we do not want shift by a-  huge amount, which can happen in code like that above.--The two cases are more different in their code paths that is comfortable,-but that is only a historical accident.---************************************************************************-*                                                                      *-\subsection{Vaguely generic functions}-*                                                                      *-************************************************************************--}--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,-                  ru_nargs = n_args,-                  ru_try   = runRuleM rm }--newtype RuleM r = RuleM-  { runRuleM :: RuleOpts -> InScopeEnv -> Id -> [CoreExpr] -> Maybe r }-  deriving (Functor)--instance Applicative RuleM where-    pure x = RuleM $ \_ _ _ _ -> Just x-    (<*>) = ap--instance Monad RuleM where-  RuleM f >>= g-    = RuleM $ \env iu fn args ->-              case f env iu fn args of-                Nothing -> Nothing-                Just r  -> runRuleM (g r) env iu fn args--instance MonadFail RuleM where-    fail _ = mzero--instance Alternative RuleM where-  empty = RuleM $ \_ _ _ _ -> Nothing-  RuleM f1 <|> RuleM f2 = RuleM $ \env iu fn args ->-    f1 env iu fn args <|> f2 env iu fn args--instance MonadPlus RuleM--getPlatform :: RuleM Platform-getPlatform = roPlatform <$> getEnv--getEnv :: RuleM RuleOpts-getEnv = RuleM $ \env _ _ _ -> Just env--liftMaybe :: Maybe a -> RuleM a-liftMaybe Nothing = mzero-liftMaybe (Just x) = return x--liftLit :: (Literal -> Literal) -> RuleM CoreExpr-liftLit f = liftLitPlatform (const f)--liftLitPlatform :: (Platform -> Literal -> Literal) -> RuleM CoreExpr-liftLitPlatform f = do-  platform <- getPlatform-  [Lit lit] <- getArgs-  return $ Lit (f platform lit)--removeOp32 :: RuleM CoreExpr-removeOp32 = do-  platform <- getPlatform-  case platformWordSize platform of-    PW4 -> do-      [e] <- getArgs-      return e-    PW8 ->-      mzero--getArgs :: RuleM [CoreExpr]-getArgs = RuleM $ \_ _ _ args -> Just args--getInScopeEnv :: RuleM InScopeEnv-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-  (Lit l:_) -> Just l-  _ -> Nothing--unaryLit :: (RuleOpts -> Literal -> Maybe CoreExpr) -> RuleM CoreExpr-unaryLit op = do-  env <- getEnv-  [Lit l] <- getArgs-  liftMaybe $ op env (convFloating env l)--binaryLit :: (RuleOpts -> Literal -> Literal -> Maybe CoreExpr) -> RuleM CoreExpr-binaryLit op = do-  env <- getEnv-  [Lit l1, Lit l2] <- getArgs-  liftMaybe $ op env (convFloating env l1) (convFloating env l2)--binaryCmpLit :: (forall a . Ord a => a -> a -> Bool) -> RuleM CoreExpr-binaryCmpLit op = do-  platform <- getPlatform-  binaryLit (\_ -> cmpOp platform op)--leftIdentity :: Literal -> RuleM CoreExpr-leftIdentity id_lit = leftIdentityPlatform (const id_lit)--rightIdentity :: Literal -> RuleM CoreExpr-rightIdentity id_lit = rightIdentityPlatform (const id_lit)--identity :: Literal -> RuleM CoreExpr-identity lit = leftIdentity lit `mplus` rightIdentity lit--leftIdentityPlatform :: (Platform -> Literal) -> RuleM CoreExpr-leftIdentityPlatform id_lit = do-  platform <- getPlatform-  [Lit l1, e2] <- getArgs-  guard $ l1 == id_lit platform-  return e2---- | Left identity rule for PrimOps like 'IntAddC' and 'WordAddC', where, in--- addition to the result, we have to indicate that no carry/overflow occurred.-leftIdentityCPlatform :: (Platform -> Literal) -> RuleM CoreExpr-leftIdentityCPlatform id_lit = do-  platform <- getPlatform-  [Lit l1, e2] <- getArgs-  guard $ l1 == id_lit platform-  let no_c = Lit (zeroi platform)-  return (mkCoreUbxTup [exprType e2, intPrimTy] [e2, no_c])--rightIdentityPlatform :: (Platform -> Literal) -> RuleM CoreExpr-rightIdentityPlatform id_lit = do-  platform <- getPlatform-  [e1, Lit l2] <- getArgs-  guard $ l2 == id_lit platform-  return e1---- | Right identity rule for PrimOps like 'IntSubC' and 'WordSubC', where, in--- addition to the result, we have to indicate that no carry/overflow occurred.-rightIdentityCPlatform :: (Platform -> Literal) -> RuleM CoreExpr-rightIdentityCPlatform id_lit = do-  platform <- getPlatform-  [e1, Lit l2] <- getArgs-  guard $ l2 == id_lit platform-  let no_c = Lit (zeroi platform)-  return (mkCoreUbxTup [exprType e1, intPrimTy] [e1, no_c])--identityPlatform :: (Platform -> Literal) -> RuleM CoreExpr-identityPlatform lit =-  leftIdentityPlatform lit `mplus` rightIdentityPlatform lit---- | Identity rule for PrimOps like 'IntAddC' and 'WordAddC', where, in addition--- to the result, we have to indicate that no carry/overflow occurred.-identityCPlatform :: (Platform -> Literal) -> RuleM CoreExpr-identityCPlatform lit =-  leftIdentityCPlatform lit `mplus` rightIdentityCPlatform lit--leftZero :: (Platform -> Literal) -> RuleM CoreExpr-leftZero zero = do-  platform <- getPlatform-  [Lit l1, _] <- getArgs-  guard $ l1 == zero platform-  return $ Lit l1--rightZero :: (Platform -> Literal) -> RuleM CoreExpr-rightZero zero = do-  platform <- getPlatform-  [_, Lit l2] <- getArgs-  guard $ l2 == zero platform-  return $ Lit l2--zeroElem :: (Platform -> Literal) -> RuleM CoreExpr-zeroElem lit = leftZero lit `mplus` rightZero lit--equalArgs :: RuleM ()-equalArgs = do-  [e1, e2] <- getArgs-  guard $ e1 `cheapEqExpr` e2--nonZeroLit :: Int -> RuleM ()-nonZeroLit n = getLiteral n >>= guard . not . isZeroLit---- When excess precision is not requested, cut down the precision of the--- Rational value to that of Float/Double. We confuse host architecture--- and target architecture here, but it's convenient (and wrong :-).-convFloating :: RuleOpts -> Literal -> Literal-convFloating env (LitFloat  f) | not (roExcessRationalPrecision env) =-   LitFloat  (toRational (fromRational f :: Float ))-convFloating env (LitDouble d) | not (roExcessRationalPrecision env) =-   LitDouble (toRational (fromRational d :: Double))-convFloating _ l = l--guardFloatDiv :: RuleM ()-guardFloatDiv = do-  [Lit (LitFloat f1), Lit (LitFloat f2)] <- getArgs-  guard $ (f1 /=0 || f2 > 0) -- see Note [negative zero]-       && f2 /= 0            -- avoid NaN and Infinity/-Infinity--guardDoubleDiv :: RuleM ()-guardDoubleDiv = do-  [Lit (LitDouble d1), Lit (LitDouble d2)] <- getArgs-  guard $ (d1 /=0 || d2 > 0) -- see Note [negative zero]-       && d2 /= 0            -- avoid NaN and Infinity/-Infinity--- Note [negative zero] Avoid (0 / -d), otherwise 0/(-1) reduces to--- zero, but we might want to preserve the negative zero here which--- is representable in Float/Double but not in (normalised)--- Rational. (#3676) Perhaps we should generate (0 :% (-1)) instead?--strengthReduction :: Literal -> PrimOp -> RuleM CoreExpr-strengthReduction two_lit add_op = do -- Note [Strength reduction]-  arg <- msum [ do [arg, Lit mult_lit] <- getArgs-                   guard (mult_lit == two_lit)-                   return arg-              , do [Lit mult_lit, arg] <- getArgs-                   guard (mult_lit == two_lit)-                   return arg ]-  return $ Var (mkPrimOpId add_op) `App` arg `App` arg---- Note [Strength reduction]--- ~~~~~~~~~~~~~~~~~~~~~~~~~------ This rule turns floating point multiplications of the form 2.0 * x and--- x * 2.0 into x + x addition, because addition costs less than multiplication.--- See #7116---- Note [What's true and false]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ trueValInt and falseValInt represent true and false values returned by--- comparison primops for Char, Int, Word, Integer, Double, Float and Addr.--- True is represented as an unboxed 1# literal, while false is represented--- as 0# literal.--- We still need Bool data constructors (True and False) to use in a rule--- for constant folding of equal Strings--trueValInt, falseValInt :: Platform -> Expr CoreBndr-trueValInt  platform = Lit $ onei  platform -- see Note [What's true and false]-falseValInt platform = Lit $ zeroi platform--trueValBool, falseValBool :: Expr CoreBndr-trueValBool   = Var trueDataConId -- see Note [What's true and false]-falseValBool  = Var falseDataConId--ltVal, eqVal, gtVal :: Expr CoreBndr-ltVal = Var ordLTDataConId-eqVal = Var ordEQDataConId-gtVal = Var ordGTDataConId--mkIntVal :: Platform -> Integer -> Expr CoreBndr-mkIntVal platform i = Lit (mkLitInt platform i)-mkFloatVal :: RuleOpts -> Rational -> Expr CoreBndr-mkFloatVal env f = Lit (convFloating env (LitFloat  f))-mkDoubleVal :: RuleOpts -> Rational -> Expr CoreBndr-mkDoubleVal env d = Lit (convFloating env (LitDouble d))--matchPrimOpId :: PrimOp -> Id -> RuleM ()-matchPrimOpId op id = do-  op' <- liftMaybe $ isPrimOpId_maybe id-  guard $ op == op'--{--************************************************************************-*                                                                      *-\subsection{Special rules for seq, tagToEnum, dataToTag}-*                                                                      *-************************************************************************--Note [tagToEnum#]-~~~~~~~~~~~~~~~~~-Nasty check to ensure that tagToEnum# is applied to a type that is an-enumeration TyCon.  Unification may refine the type later, but this-check won't see that, alas.  It's crude but it works.--Here's are two cases that should fail-        f :: forall a. a-        f = tagToEnum# 0        -- Can't do tagToEnum# at a type variable--        g :: Int-        g = tagToEnum# 0        -- Int is not an enumeration--We used to make this check in the type inference engine, but it's quite-ugly to do so, because the delayed constraint solving means that we don't-really know what's going on until the end. It's very much a corner case-because we don't expect the user to call tagToEnum# at all; we merely-generate calls in derived instances of Enum.  So we compromise: a-rewrite rule rewrites a bad instance of tagToEnum# to an error call,-and emits a warning.--}--tagToEnumRule :: RuleM CoreExpr--- If     data T a = A | B | C--- then   tagToEnum# (T ty) 2# -->  B ty-tagToEnumRule = do-  [Type ty, Lit (LitNumber LitNumInt i _)] <- getArgs-  case splitTyConApp_maybe ty of-    Just (tycon, tc_args) | isEnumerationTyCon tycon -> do-      let tag = fromInteger i-          correct_tag dc = (dataConTagZ dc) == tag-      (dc:rest) <- return $ filter correct_tag (tyConDataCons_maybe tycon `orElse` [])-      ASSERT(null rest) return ()-      return $ mkTyApps (Var (dataConWorkId dc)) tc_args--    -- See Note [tagToEnum#]-    _ -> WARN( True, text "tagToEnum# on non-enumeration type" <+> ppr ty )-         return $ mkRuntimeErrorApp rUNTIME_ERROR_ID ty "tagToEnum# on non-enumeration type"---------------------------------dataToTagRule :: RuleM CoreExpr--- See Note [dataToTag#] in primops.txt.pp-dataToTagRule = a `mplus` b-  where-    -- dataToTag (tagToEnum x)   ==>   x-    a = do-      [Type ty1, Var tag_to_enum `App` Type ty2 `App` tag] <- getArgs-      guard $ tag_to_enum `hasKey` tagToEnumKey-      guard $ ty1 `eqType` ty2-      return tag--    -- dataToTag (K e1 e2)  ==>   tag-of K-    -- This also works (via exprIsConApp_maybe) for-    --   dataToTag x-    -- where x's unfolding is a constructor application-    b = do-      dflags <- getPlatform-      [_, val_arg] <- getArgs-      in_scope <- getInScopeEnv-      (_,floats, dc,_,_) <- liftMaybe $ exprIsConApp_maybe in_scope val_arg-      ASSERT( not (isNewTyCon (dataConTyCon dc)) ) return ()-      return $ wrapFloats floats (mkIntVal dflags (toInteger (dataConTagZ dc)))--{- Note [dataToTag# magic]-~~~~~~~~~~~~~~~~~~~~~~~~~~-The primop dataToTag# is unusual because it evaluates its argument.-Only `SeqOp` shares that property.  (Other primops do not do anything-as fancy as argument evaluation.)  The special handling for dataToTag#-is:--* 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 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-  the returned value.--* An application like (dataToTag# (Just x)) is optimised by-  dataToTagRule in GHC.Core.Op.ConstantFold.--* A case expression like-     case (dataToTag# e) of <alts>-  gets transformed t-     case e of <transformed alts>-  by GHC.Core.Op.ConstantFold.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]) }---{- *********************************************************************-*                                                                      *-             Rules for seq# and spark#-*                                                                      *-********************************************************************* -}--{- Note [seq# magic]-~~~~~~~~~~~~~~~~~~~~-The primop-   seq# :: forall a s . a -> State# s -> (# State# s, a #)--is /not/ the same as the Prelude function seq :: a -> b -> b-as you can see from its type.  In fact, seq# is the implementation-mechanism for 'evaluate'--   evaluate :: a -> IO a-   evaluate a = IO $ \s -> seq# a s--The semantics of seq# is-  * evaluate its first argument-  * and return it--Things to note--* Why do we need a primop at all?  That is, instead of-      case seq# x s of (# x, s #) -> blah-  why not instead say this?-      case x of { DEFAULT -> blah)--  Reason (see #5129): if we saw-    catch# (\s -> case x of { DEFAULT -> raiseIO# exn s }) handler--  then we'd drop the 'case x' because the body of the case is bottom-  anyway. But we don't want to do that; the whole /point/ of-  seq#/evaluate is to evaluate 'x' first in the IO monad.--  In short, we /always/ evaluate the first argument and never-  just discard it.--* Why return the value?  So that we can control sharing of seq'd-  values: in-     let x = e in x `seq` ... x ...-  We don't want to inline x, so better to represent it as-       let x = e in case seq# x RW of (# _, x' #) -> ... x' ...-  also it matches the type of rseq in the Eval monad.--Implementing seq#.  The compiler has magic for SeqOp in--- GHC.Core.Op.ConstantFold.seqRule: eliminate (seq# <whnf> s)--- GHC.StgToCmm.Expr.cgExpr, and cgCase: special case for seq#--- 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]-  in GHC.Core.Op.Simplify--}--seqRule :: RuleM CoreExpr-seqRule = do-  [Type ty_a, Type _ty_s, a, s] <- getArgs-  guard $ exprIsHNF a-  return $ mkCoreUbxTup [exprType s, ty_a] [s, a]---- spark# :: forall a s . a -> State# s -> (# State# s, a #)-sparkRule :: RuleM CoreExpr-sparkRule = seqRule -- reduce on HNF, just the same-  -- XXX perhaps we shouldn't do this, because a spark eliminated by-  -- this rule won't be counted as a dud at runtime?--{--************************************************************************-*                                                                      *-\subsection{Built in rules}-*                                                                      *-************************************************************************--Note [Scoping for Builtin rules]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When compiling a (base-package) module that defines one of the-functions mentioned in the RHS of a built-in rule, there's a danger-that we'll see--        f = ...(eq String x)....--        ....and lower down...--        eqString = ...--Then a rewrite would give--        f = ...(eqString x)...-        ....and lower down...-        eqString = ...--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]--- Rules for non-primops that can't be expressed using a RULE pragma-builtinRules-  = [BuiltinRule { ru_name = fsLit "AppendLitString",-                   ru_fn = unpackCStringFoldrName,-                   ru_nargs = 4, ru_try = match_append_lit },-     BuiltinRule { ru_name = fsLit "EqString", ru_fn = eqStringName,-                   ru_nargs = 2, ru_try = match_eq_string },-     BuiltinRule { ru_name = fsLit "Inline", ru_fn = inlineIdName,-                   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-        , do-          [arg, Lit (LitNumber LitNumInt d _)] <- getArgs-          Just n <- return $ exactLog2 d-          platform <- getPlatform-          return $ Var (mkPrimOpId ISraOp) `App` arg `App` mkIntVal platform n-        ],--     mkBasicRule modIntName 2 $ msum-        [ nonZeroLit 1 >> binaryLit (intOp2 mod)-        , leftZero zeroi-        , do-          [arg, Lit (LitNumber LitNumInt d _)] <- getArgs-          Just _ <- return $ exactLog2 d-          platform <- getPlatform-          return $ Var (mkPrimOpId AndIOp)-            `App` arg `App` mkIntVal platform (d - 1)-        ]-     ]- ++ builtinIntegerRules- ++ builtinNaturalRules-{-# NOINLINE builtinRules #-}--- there is no benefit to inlining these yet, despite this, GHC produces--- unfoldings for this regardless since the floated list entries look small.--builtinIntegerRules :: [CoreRule]-builtinIntegerRules =- [rule_IntToInteger   "smallInteger"        smallIntegerName,-  rule_WordToInteger  "wordToInteger"       wordToIntegerName,-  rule_Int64ToInteger  "int64ToInteger"     int64ToIntegerName,-  rule_Word64ToInteger "word64ToInteger"    word64ToIntegerName,-  rule_convert        "integerToWord"       integerToWordName       mkWordLitWord,-  rule_convert        "integerToInt"        integerToIntName        mkIntLitInt,-  rule_convert        "integerToWord64"     integerToWord64Name     (\_ -> mkWord64LitWord64),-  rule_convert        "integerToInt64"      integerToInt64Name      (\_ -> mkInt64LitInt64),-  rule_binop          "plusInteger"         plusIntegerName         (+),-  rule_binop          "minusInteger"        minusIntegerName        (-),-  rule_binop          "timesInteger"        timesIntegerName        (*),-  rule_unop           "negateInteger"       negateIntegerName       negate,-  rule_binop_Prim     "eqInteger#"          eqIntegerPrimName       (==),-  rule_binop_Prim     "neqInteger#"         neqIntegerPrimName      (/=),-  rule_unop           "absInteger"          absIntegerName          abs,-  rule_unop           "signumInteger"       signumIntegerName       signum,-  rule_binop_Prim     "leInteger#"          leIntegerPrimName       (<=),-  rule_binop_Prim     "gtInteger#"          gtIntegerPrimName       (>),-  rule_binop_Prim     "ltInteger#"          ltIntegerPrimName       (<),-  rule_binop_Prim     "geInteger#"          geIntegerPrimName       (>=),-  rule_binop_Ordering "compareInteger"      compareIntegerName      compare,-  rule_encodeFloat    "encodeFloatInteger"  encodeFloatIntegerName  mkFloatLitFloat,-  rule_convert        "floatFromInteger"    floatFromIntegerName    (\_ -> mkFloatLitFloat),-  rule_encodeFloat    "encodeDoubleInteger" encodeDoubleIntegerName mkDoubleLitDouble,-  rule_decodeDouble   "decodeDoubleInteger" decodeDoubleIntegerName,-  rule_convert        "doubleFromInteger"   doubleFromIntegerName   (\_ -> mkDoubleLitDouble),-  rule_rationalTo     "rationalToFloat"     rationalToFloatName     mkFloatExpr,-  rule_rationalTo     "rationalToDouble"    rationalToDoubleName    mkDoubleExpr,-  rule_binop          "gcdInteger"          gcdIntegerName          gcd,-  rule_binop          "lcmInteger"          lcmIntegerName          lcm,-  rule_binop          "andInteger"          andIntegerName          (.&.),-  rule_binop          "orInteger"           orIntegerName           (.|.),-  rule_binop          "xorInteger"          xorIntegerName          xor,-  rule_unop           "complementInteger"   complementIntegerName   complement,-  rule_shift_op       "shiftLInteger"       shiftLIntegerName       shiftL,-  rule_shift_op       "shiftRInteger"       shiftRIntegerName       shiftR,-  rule_bitInteger     "bitInteger"          bitIntegerName,-  -- See Note [Integer division constant folding] in libraries/base/GHC/Real.hs-  rule_divop_one      "quotInteger"         quotIntegerName         quot,-  rule_divop_one      "remInteger"          remIntegerName          rem,-  rule_divop_one      "divInteger"          divIntegerName          div,-  rule_divop_one      "modInteger"          modIntegerName          mod,-  rule_divop_both     "divModInteger"       divModIntegerName       divMod,-  rule_divop_both     "quotRemInteger"      quotRemIntegerName      quotRem,-  -- These rules below don't actually have to be built in, but if we-  -- put them in the Haskell source then we'd have to duplicate them-  -- between all Integer implementations-  rule_XToIntegerToX "smallIntegerToInt"       integerToIntName    smallIntegerName,-  rule_XToIntegerToX "wordToIntegerToWord"     integerToWordName   wordToIntegerName,-  rule_XToIntegerToX "int64ToIntegerToInt64"   integerToInt64Name  int64ToIntegerName,-  rule_XToIntegerToX "word64ToIntegerToWord64" integerToWord64Name word64ToIntegerName,-  rule_smallIntegerTo "smallIntegerToWord"   integerToWordName     Int2WordOp,-  rule_smallIntegerTo "smallIntegerToFloat"  floatFromIntegerName  Int2FloatOp,-  rule_smallIntegerTo "smallIntegerToDouble" doubleFromIntegerName Int2DoubleOp-  ]-    where rule_convert str name convert-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_Integer_convert convert }-          rule_IntToInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_IntToInteger }-          rule_WordToInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_WordToInteger }-          rule_Int64ToInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_Int64ToInteger }-          rule_Word64ToInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_Word64ToInteger }-          rule_unop str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_Integer_unop op }-          rule_bitInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_bitInteger }-          rule_binop str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_binop op }-          rule_divop_both str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_divop_both op }-          rule_divop_one str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_divop_one op }-          rule_shift_op str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_shift_op op }-          rule_binop_Prim str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_binop_Prim op }-          rule_binop_Ordering str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_binop_Ordering op }-          rule_encodeFloat str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Integer_Int_encodeFloat op }-          rule_decodeDouble str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_decodeDouble }-          rule_XToIntegerToX str name toIntegerName-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_XToIntegerToX toIntegerName }-          rule_smallIntegerTo str name primOp-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_smallIntegerTo primOp }-          rule_rationalTo str name mkLit-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_rationalTo mkLit }--builtinNaturalRules :: [CoreRule]-builtinNaturalRules =- [rule_binop              "plusNatural"        plusNaturalName         (+)- ,rule_partial_binop      "minusNatural"       minusNaturalName        (\a b -> if a >= b then Just (a - b) else Nothing)- ,rule_binop              "timesNatural"       timesNaturalName        (*)- ,rule_NaturalFromInteger "naturalFromInteger" naturalFromIntegerName- ,rule_NaturalToInteger   "naturalToInteger"   naturalToIntegerName- ,rule_WordToNatural      "wordToNatural"      wordToNaturalName- ]-    where rule_binop str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Natural_binop op }-          rule_partial_binop str name op-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,-                           ru_try = match_Natural_partial_binop op }-          rule_NaturalToInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_NaturalToInteger }-          rule_NaturalFromInteger str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_NaturalFromInteger }-          rule_WordToNatural str name-           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,-                           ru_try = match_WordToNatural }-------------------------------------------------------- The rule is this:---      unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n)---      =  unpackFoldrCString# "foobaz" c n--match_append_lit :: RuleFun-match_append_lit _ id_unf _-        [ Type ty1-        , lit1-        , c1-        , e2-        ]-  -- N.B. Ensure that we strip off any ticks (e.g. source notes) from the-  -- `lit` and `c` arguments, lest this may fail to fire when building with-  -- -g3. See #16740.-  | (strTicks, Var unpk `App` Type ty2-                        `App` lit2-                        `App` c2-                        `App` n) <- stripTicksTop tickishFloatable e2-  , unpk `hasKey` unpackCStringFoldrIdKey-  , cheapEqExpr' tickishFloatable c1 c2-  , (c1Ticks, c1') <- stripTicksTop tickishFloatable c1-  , c2Ticks <- stripTicksTopT tickishFloatable c2-  , Just (LitString s1) <- exprIsLiteral_maybe id_unf lit1-  , Just (LitString s2) <- exprIsLiteral_maybe id_unf lit2-  = ASSERT( ty1 `eqType` ty2 )-    Just $ mkTicks strTicks-         $ Var unpk `App` Type ty1-                    `App` Lit (LitString (s1 `BS.append` s2))-                    `App` mkTicks (c1Ticks ++ c2Ticks) c1'-                    `App` n--match_append_lit _ _ _ _ = Nothing-------------------------------------------------------- The rule is this:---      eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2)) = s1==s2--match_eq_string :: RuleFun-match_eq_string _ id_unf _-        [Var unpk1 `App` lit1, Var unpk2 `App` lit2]-  | unpk1 `hasKey` unpackCStringIdKey-  , unpk2 `hasKey` unpackCStringIdKey-  , Just (LitString s1) <- exprIsLiteral_maybe id_unf lit1-  , Just (LitString s2) <- exprIsLiteral_maybe id_unf lit2-  = Just (if s1 == s2 then trueValBool else falseValBool)--match_eq_string _ _ _ _ = Nothing--------------------------------------------------------- The rule is this:---      inline f_ty (f a b c) = <f's unfolding> a b c--- (if f has an unfolding, EVEN if it's a loop breaker)------ It's important to allow the argument to 'inline' to have args itself--- (a) because its more forgiving to allow the programmer to write---       inline f a b c---   or  inline (f a b c)--- (b) because a polymorphic f wll get a type argument that the---     programmer can't avoid------ Also, don't forget about 'inline's type argument!-match_inline :: [Expr CoreBndr] -> Maybe (Expr CoreBndr)-match_inline (Type _ : e : _)-  | (Var f, args1) <- collectArgs e,-    Just unf <- maybeUnfoldingTemplate (realIdUnfolding f)-             -- Ignore the IdUnfoldingFun here!-  = Just (mkApps unf args1)--match_inline _ = Nothing----- See Note [magicDictId magic] in `basicTypes/MkId.hs`--- for a description of what is going on here.-match_magicDict :: [Expr CoreBndr] -> Maybe (Expr CoreBndr)-match_magicDict [Type _, Var wrap `App` Type a `App` Type _ `App` f, x, y ]-  | Just (fieldTy, _)   <- splitFunTy_maybe $ dropForAlls $ idType wrap-  , Just (dictTy, _)    <- splitFunTy_maybe fieldTy-  , Just dictTc         <- tyConAppTyCon_maybe dictTy-  , Just (_,_,co)       <- unwrapNewTyCon_maybe dictTc-  = Just-  $ f `App` Cast x (mkSymCo (mkUnbranchedAxInstCo Representational co [a] []))-      `App` y--match_magicDict _ = Nothing------------------------------------------------------ Integer rules---   smallInteger  (79::Int#)  = 79::Integer---   wordToInteger (79::Word#) = 79::Integer--- Similarly Int64, Word64--match_IntToInteger :: RuleFun-match_IntToInteger = match_IntToInteger_unop id--match_WordToInteger :: RuleFun-match_WordToInteger _ id_unf id [xl]-  | Just (LitNumber LitNumWord x _) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType id) of-    Just (_, integerTy) ->-        Just (Lit (mkLitInteger x integerTy))-    _ ->-        panic "match_WordToInteger: Id has the wrong type"-match_WordToInteger _ _ _ _ = Nothing--match_Int64ToInteger :: RuleFun-match_Int64ToInteger _ id_unf id [xl]-  | Just (LitNumber LitNumInt64 x _) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType id) of-    Just (_, integerTy) ->-        Just (Lit (mkLitInteger x integerTy))-    _ ->-        panic "match_Int64ToInteger: Id has the wrong type"-match_Int64ToInteger _ _ _ _ = Nothing--match_Word64ToInteger :: RuleFun-match_Word64ToInteger _ id_unf id [xl]-  | Just (LitNumber LitNumWord64 x _) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType id) of-    Just (_, integerTy) ->-        Just (Lit (mkLitInteger x integerTy))-    _ ->-        panic "match_Word64ToInteger: Id has the wrong type"-match_Word64ToInteger _ _ _ _ = Nothing--match_NaturalToInteger :: RuleFun-match_NaturalToInteger _ id_unf id [xl]-  | Just (LitNumber LitNumNatural x _) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType id) of-    Just (_, naturalTy) ->-        Just (Lit (LitNumber LitNumInteger x naturalTy))-    _ ->-        panic "match_NaturalToInteger: Id has the wrong type"-match_NaturalToInteger _ _ _ _ = Nothing--match_NaturalFromInteger :: RuleFun-match_NaturalFromInteger _ id_unf id [xl]-  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl-  , x >= 0-  = case splitFunTy_maybe (idType id) of-    Just (_, naturalTy) ->-        Just (Lit (LitNumber LitNumNatural x naturalTy))-    _ ->-        panic "match_NaturalFromInteger: Id has the wrong type"-match_NaturalFromInteger _ _ _ _ = Nothing--match_WordToNatural :: RuleFun-match_WordToNatural _ id_unf id [xl]-  | Just (LitNumber LitNumWord x _) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType id) of-    Just (_, naturalTy) ->-        Just (Lit (LitNumber LitNumNatural x naturalTy))-    _ ->-        panic "match_WordToNatural: Id has the wrong type"-match_WordToNatural _ _ _ _ = Nothing----------------------------------------------------{- Note [Rewriting bitInteger]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-For most types the bitInteger operation can be implemented in terms of shifts.-The integer-gmp package, however, can do substantially better than this if-allowed to provide its own implementation. However, in so doing it previously lost-constant-folding (see #8832). The bitInteger rule above provides constant folding-specifically for this function.--There is, however, a bit of trickiness here when it comes to ranges. While the-AST encodes all integers as Integers, `bit` expects the bit-index to be given as an Int. Hence we coerce to an Int in the rule definition.-This will behave a bit funny for constants larger than the word size, but the user-should expect some funniness given that they will have at very least ignored a-warning in this case.--}--match_bitInteger :: RuleFun--- Just for GHC.Integer.Type.bitInteger :: Int# -> Integer-match_bitInteger env id_unf fn [arg]-  | Just (LitNumber LitNumInt x _) <- exprIsLiteral_maybe id_unf arg-  , x >= 0-  , x <= (toInteger (platformWordSizeInBits (roPlatform env)) - 1)-    -- Make sure x is small enough to yield a decently small integer-    -- Attempting to construct the Integer for-    --    (bitInteger 9223372036854775807#)-    -- would be a bad idea (#14959)-  , let x_int = fromIntegral x :: Int-  = case splitFunTy_maybe (idType fn) of-    Just (_, integerTy)-      -> Just (Lit (LitNumber LitNumInteger (bit x_int) integerTy))-    _ -> panic "match_IntToInteger_unop: Id has the wrong type"--match_bitInteger _ _ _ _ = Nothing-----------------------------------------------------match_Integer_convert :: Num a-                      => (Platform -> a -> Expr CoreBndr)-                      -> RuleFun-match_Integer_convert convert env id_unf _ [xl]-  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl-  = Just (convert (roPlatform env) (fromInteger x))-match_Integer_convert _ _ _ _ _ = Nothing--match_Integer_unop :: (Integer -> Integer) -> RuleFun-match_Integer_unop unop _ id_unf _ [xl]-  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl-  = Just (Lit (LitNumber LitNumInteger (unop x) i))-match_Integer_unop _ _ _ _ _ = Nothing--match_IntToInteger_unop :: (Integer -> Integer) -> RuleFun-match_IntToInteger_unop unop _ id_unf fn [xl]-  | Just (LitNumber LitNumInt x _) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType fn) of-    Just (_, integerTy) ->-        Just (Lit (LitNumber LitNumInteger (unop x) integerTy))-    _ ->-        panic "match_IntToInteger_unop: Id has the wrong type"-match_IntToInteger_unop _ _ _ _ _ = Nothing--match_Integer_binop :: (Integer -> Integer -> Integer) -> RuleFun-match_Integer_binop binop _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl-  = Just (Lit (mkLitInteger (x `binop` y) i))-match_Integer_binop _ _ _ _ _ = Nothing--match_Natural_binop :: (Integer -> Integer -> Integer) -> RuleFun-match_Natural_binop binop _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumNatural x i) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumNatural y _) <- exprIsLiteral_maybe id_unf yl-  = Just (Lit (mkLitNatural (x `binop` y) i))-match_Natural_binop _ _ _ _ _ = Nothing--match_Natural_partial_binop :: (Integer -> Integer -> Maybe Integer) -> RuleFun-match_Natural_partial_binop binop _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumNatural x i) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumNatural y _) <- exprIsLiteral_maybe id_unf yl-  , Just z <- x `binop` y-  = Just (Lit (mkLitNatural z i))-match_Natural_partial_binop _ _ _ _ _ = Nothing---- This helper is used for the quotRem and divMod functions-match_Integer_divop_both-   :: (Integer -> Integer -> (Integer, Integer)) -> RuleFun-match_Integer_divop_both divop _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumInteger x t) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl-  , y /= 0-  , (r,s) <- x `divop` y-  = Just $ mkCoreUbxTup [t,t] [Lit (mkLitInteger r t), Lit (mkLitInteger s t)]-match_Integer_divop_both _ _ _ _ _ = Nothing---- This helper is used for the quot and rem functions-match_Integer_divop_one :: (Integer -> Integer -> Integer) -> RuleFun-match_Integer_divop_one divop _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl-  , y /= 0-  = Just (Lit (mkLitInteger (x `divop` y) i))-match_Integer_divop_one _ _ _ _ _ = Nothing--match_Integer_shift_op :: (Integer -> Int -> Integer) -> RuleFun--- Used for shiftLInteger, shiftRInteger :: Integer -> Int# -> Integer--- See Note [Guarding against silly shifts]-match_Integer_shift_op binop _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInt y _)     <- exprIsLiteral_maybe id_unf yl-  , y >= 0-  , y <= 4   -- Restrict constant-folding of shifts on Integers, somewhat-             -- arbitrary.  We can get huge shifts in inaccessible code-             -- (#15673)-  = Just (Lit (mkLitInteger (x `binop` fromIntegral y) i))-match_Integer_shift_op _ _ _ _ _ = Nothing--match_Integer_binop_Prim :: (Integer -> Integer -> Bool) -> RuleFun-match_Integer_binop_Prim binop env id_unf _ [xl, yl]-  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl-  = Just (if x `binop` y then trueValInt (roPlatform env) else falseValInt (roPlatform env))-match_Integer_binop_Prim _ _ _ _ _ = Nothing--match_Integer_binop_Ordering :: (Integer -> Integer -> Ordering) -> RuleFun-match_Integer_binop_Ordering binop _ id_unf _ [xl, yl]-  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl-  = Just $ case x `binop` y of-             LT -> ltVal-             EQ -> eqVal-             GT -> gtVal-match_Integer_binop_Ordering _ _ _ _ _ = Nothing--match_Integer_Int_encodeFloat :: RealFloat a-                              => (a -> Expr CoreBndr)-                              -> RuleFun-match_Integer_Int_encodeFloat mkLit _ id_unf _ [xl,yl]-  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInt y _)     <- exprIsLiteral_maybe id_unf yl-  = Just (mkLit $ encodeFloat x (fromInteger y))-match_Integer_Int_encodeFloat _ _ _ _ _ = Nothing-------------------------------------------------------- constant folding for Float/Double------ This turns---      rationalToFloat n d--- into a literal Float, and similarly for Doubles.------ it's important to not match d == 0, because that may represent a--- literal "0/0" or similar, and we can't produce a literal value for--- NaN or +-Inf-match_rationalTo :: RealFloat a-                 => (a -> Expr CoreBndr)-                 -> RuleFun-match_rationalTo mkLit _ id_unf _ [xl, yl]-  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl-  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl-  , y /= 0-  = Just (mkLit (fromRational (x % y)))-match_rationalTo _ _ _ _ _ = Nothing--match_decodeDouble :: RuleFun-match_decodeDouble env id_unf fn [xl]-  | Just (LitDouble x) <- exprIsLiteral_maybe id_unf xl-  = case splitFunTy_maybe (idType fn) of-    Just (_, res)-      | Just [_lev1, _lev2, integerTy, intHashTy] <- tyConAppArgs_maybe res-      -> case decodeFloat (fromRational x :: Double) of-           (y, z) ->-             Just $ mkCoreUbxTup [integerTy, intHashTy]-                                 [Lit (mkLitInteger y integerTy),-                                  Lit (mkLitInt (roPlatform env) (toInteger z))]-    _ ->-        pprPanic "match_decodeDouble: Id has the wrong type"-          (ppr fn <+> dcolon <+> ppr (idType fn))-match_decodeDouble _ _ _ _ = Nothing--match_XToIntegerToX :: Name -> RuleFun-match_XToIntegerToX n _ _ _ [App (Var x) y]-  | idName x == n-  = Just y-match_XToIntegerToX _ _ _ _ _ = Nothing--match_smallIntegerTo :: PrimOp -> RuleFun-match_smallIntegerTo primOp _ _ _ [App (Var x) y]-  | idName x == smallIntegerName-  = Just $ App (Var (mkPrimOpId primOp)) y-match_smallIntegerTo _ _ _ _ _ = Nothing--------------------------------------------------------------- Note [Constant folding through nested expressions]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ We use rewrites rules to perform constant folding. It means that we don't--- have a global view of the expression we are trying to optimise. As a--- consequence we only perform local (small-step) transformations that either:---    1) reduce the number of operations---    2) rearrange the expression to increase the odds that other rules will---    match------ We don't try to handle more complex expression optimisation cases that would--- require a global view. For example, rewriting expressions to increase--- sharing (e.g., Horner's method); optimisations that require local--- transformations increasing the number of operations; rearrangements to--- cancel/factorize terms (e.g., (a+b-a-b) isn't rearranged to reduce to 0).------ We already have rules to perform constant folding on expressions with the--- following shape (where a and/or b are literals):------          D)    op---                /\---               /  \---              /    \---             a      b------ To support nested expressions, we match three other shapes of expression--- trees:------ A)   op1          B)       op1       C)       op1---      /\                    /\                 /\---     /  \                  /  \               /  \---    /    \                /    \             /    \---   a     op2            op2     c          op2    op3---          /\            /\                 /\      /\---         /  \          /  \               /  \    /  \---        b    c        a    b             a    b  c    d--------- R1) +/- simplification:---    ops = + or -, two literals (not siblings)------    Examples:---       A: 5 + (10-x)  ==> 15-x---       B: (10+x) + 5  ==> 15+x---       C: (5+a)-(5-b) ==> 0+(a+b)------ R2) * simplification---    ops = *, two literals (not siblings)------    Examples:---       A: 5 * (10*x)  ==> 50*x---       B: (10*x) * 5  ==> 50*x---       C: (5*a)*(5*b) ==> 25*(a*b)------ R3) * distribution over +/----    op1 = *, op2 = + or -, two literals (not siblings)------    This transformation doesn't reduce the number of operations but switches---    the outer and the inner operations so that the outer is (+) or (-) instead---    of (*). It increases the odds that other rules will match after this one.------    Examples:---       A: 5 * (10-x)  ==> 50 - (5*x)---       B: (10+x) * 5  ==> 50 + (5*x)---       C: Not supported as it would increase the number of operations:---          (5+a)*(5-b) ==> 25 - 5*b + 5*a - a*b------ R4) Simple factorization------    op1 = + or -, op2/op3 = *,---    one literal for each innermost * operation (except in the D case),---    the two other terms are equals------    Examples:---       A: x - (10*x)  ==> (-9)*x---       B: (10*x) + x  ==> 11*x---       C: (5*x)-(x*3) ==> 2*x---       D: x+x         ==> 2*x------ R5) +/- propagation------    ops = + or -, one literal------    This transformation doesn't reduce the number of operations but propagates---    the constant to the outer level. It increases the odds that other rules---    will match after this one.------    Examples:---       A: x - (10-y)  ==> (x+y) - 10---       B: (10+x) - y  ==> 10 + (x-y)---       C: N/A (caught by the A and B cases)---------------------------------------------------------------- | Rules to perform constant folding into nested expressions------See Note [Constant folding through nested expressions]-numFoldingRules :: PrimOp -> (Platform -> PrimOps) -> RuleM CoreExpr-numFoldingRules op dict = do-  env <- getEnv-  if not (roNumConstantFolding env)-   then mzero-   else do-    [e1,e2] <- getArgs-    platform <- getPlatform-    let PrimOps{..} = dict platform-    case BinOpApp e1 op e2 of-     -- R1) +/- simplification-     x    :++: (y :++: v)          -> return $ mkL (x+y)   `add` v-     x    :++: (L y :-: v)         -> return $ mkL (x+y)   `sub` v-     x    :++: (v   :-: L y)       -> return $ mkL (x-y)   `add` v-     L x  :-:  (y :++: v)          -> return $ mkL (x-y)   `sub` v-     L x  :-:  (L y :-: v)         -> return $ mkL (x-y)   `add` v-     L x  :-:  (v   :-: L y)       -> return $ mkL (x+y)   `sub` v--     (y :++: v)    :-: L x         -> return $ mkL (y-x)   `add` v-     (L y :-: v)   :-: L x         -> return $ mkL (y-x)   `sub` v-     (v   :-: L y) :-: L x         -> return $ mkL (0-y-x) `add` v--     (x :++: w)  :+: (y :++: v)    -> return $ mkL (x+y)   `add` (w `add` v)-     (w :-: L x) :+: (L y :-: v)   -> return $ mkL (y-x)   `add` (w `sub` v)-     (w :-: L x) :+: (v   :-: L y) -> return $ mkL (0-x-y) `add` (w `add` v)-     (L x :-: w) :+: (L y :-: v)   -> return $ mkL (x+y)   `sub` (w `add` v)-     (L x :-: w) :+: (v   :-: L y) -> return $ mkL (x-y)   `add` (v `sub` w)-     (w :-: L x) :+: (y :++: v)    -> return $ mkL (y-x)   `add` (w `add` v)-     (L x :-: w) :+: (y :++: v)    -> return $ mkL (x+y)   `add` (v `sub` w)-     (y :++: v)  :+: (w :-: L x)   -> return $ mkL (y-x)   `add` (w `add` v)-     (y :++: v)  :+: (L x :-: w)   -> return $ mkL (x+y)   `add` (v `sub` w)--     (v   :-: L y) :-: (w :-: L x) -> return $ mkL (x-y)   `add` (v `sub` w)-     (v   :-: L y) :-: (L x :-: w) -> return $ mkL (0-x-y) `add` (v `add` w)-     (L y :-:   v) :-: (w :-: L x) -> return $ mkL (x+y)   `sub` (v `add` w)-     (L y :-:   v) :-: (L x :-: w) -> return $ mkL (y-x)   `add` (w `sub` v)-     (x :++: w)    :-: (y :++: v)  -> return $ mkL (x-y)   `add` (w `sub` v)-     (w :-: L x)   :-: (y :++: v)  -> return $ mkL (0-y-x) `add` (w `sub` v)-     (L x :-: w)   :-: (y :++: v)  -> return $ mkL (x-y)   `sub` (v `add` w)-     (y :++: v)    :-: (w :-: L x) -> return $ mkL (y+x)   `add` (v `sub` w)-     (y :++: v)    :-: (L x :-: w) -> return $ mkL (y-x)   `add` (v `add` w)--     -- R2) * simplification-     x :**: (y :**: v)             -> return $ mkL (x*y)   `mul` v-     (x :**: w) :*: (y :**: v)     -> return $ mkL (x*y)   `mul` (w `mul` v)--     -- R3) * distribution over +/--     x :**: (y :++: v)             -> return $ mkL (x*y)   `add` (mkL x `mul` v)-     x :**: (L y :-: v)            -> return $ mkL (x*y)   `sub` (mkL x `mul` v)-     x :**: (v   :-: L y)          -> return $ (mkL x `mul` v) `sub` mkL (x*y)--     -- R4) Simple factorization-     v :+: w-      | w `cheapEqExpr` v          -> return $ mkL 2       `mul` v-     w :+: (y :**: v)-      | w `cheapEqExpr` v          -> return $ mkL (1+y)   `mul` v-     w :-: (y :**: v)-      | w `cheapEqExpr` v          -> return $ mkL (1-y)   `mul` v-     (y :**: v) :+: w-      | w `cheapEqExpr` v          -> return $ mkL (y+1)   `mul` v-     (y :**: v) :-: w-      | w `cheapEqExpr` v          -> return $ mkL (y-1)   `mul` v-     (x :**: w) :+: (y :**: v)-      | w `cheapEqExpr` v          -> return $ mkL (x+y)   `mul` v-     (x :**: w) :-: (y :**: v)-      | w `cheapEqExpr` v          -> return $ mkL (x-y)   `mul` v--     -- R5) +/- propagation-     w  :+: (y :++: v)             -> return $ mkL y `add` (w `add` v)-     (y :++: v) :+: w              -> return $ mkL y       `add` (w `add` v)-     w  :-: (y :++: v)             -> return $ (w `sub` v) `sub` mkL y-     (y :++: v) :-: w              -> return $ mkL y       `add` (v `sub` w)-     w    :-: (L y :-: v)          -> return $ (w `add` v) `sub` mkL y-     (L y :-: v) :-: w             -> return $ mkL y       `sub` (w `add` v)-     w    :+: (L y :-: v)          -> return $ mkL y       `add` (w `sub` v)-     w    :+: (v :-: L y)          -> return $ (w `add` v) `sub` mkL y-     (L y :-: v) :+: w             -> return $ mkL y       `add` (w `sub` v)-     (v :-: L y) :+: w             -> return $ (w `add` v) `sub` mkL y--     _                             -> mzero------ | Match the application of a binary primop-pattern BinOpApp  :: Arg CoreBndr -> PrimOp -> Arg CoreBndr -> CoreExpr-pattern BinOpApp  x op y =  OpVal op `App` x `App` y---- | Match a primop-pattern OpVal   :: PrimOp  -> Arg CoreBndr-pattern OpVal   op     <- Var (isPrimOpId_maybe -> Just op) where-   OpVal op = Var (mkPrimOpId op)------ | Match a literal-pattern L :: Integer -> Arg CoreBndr-pattern L l <- Lit (isLitValue_maybe -> Just l)---- | Match an addition-pattern (:+:) :: Arg CoreBndr -> Arg CoreBndr -> CoreExpr-pattern x :+: y <- BinOpApp x (isAddOp -> True) y---- | Match an addition with a literal (handle commutativity)-pattern (:++:) :: Integer -> Arg CoreBndr -> CoreExpr-pattern l :++: x <- (isAdd -> Just (l,x))--isAdd :: CoreExpr -> Maybe (Integer,CoreExpr)-isAdd e = case e of-   L l :+: x   -> Just (l,x)-   x   :+: L l -> Just (l,x)-   _           -> Nothing---- | Match a multiplication-pattern (:*:) :: Arg CoreBndr -> Arg CoreBndr -> CoreExpr-pattern x :*: y <- BinOpApp x (isMulOp -> True) y---- | Match a multiplication with a literal (handle commutativity)-pattern (:**:) :: Integer -> Arg CoreBndr -> CoreExpr-pattern l :**: x <- (isMul -> Just (l,x))--isMul :: CoreExpr -> Maybe (Integer,CoreExpr)-isMul e = case e of-   L l :*: x   -> Just (l,x)-   x   :*: L l -> Just (l,x)-   _           -> Nothing----- | Match a subtraction-pattern (:-:) :: Arg CoreBndr -> Arg CoreBndr -> CoreExpr-pattern x :-: y <- BinOpApp x (isSubOp -> True) y--isSubOp :: PrimOp -> Bool-isSubOp IntSubOp  = True-isSubOp WordSubOp = True-isSubOp _         = False--isAddOp :: PrimOp -> Bool-isAddOp IntAddOp  = True-isAddOp WordAddOp = True-isAddOp _         = False--isMulOp :: PrimOp -> Bool-isMulOp IntMulOp  = True-isMulOp WordMulOp = True-isMulOp _         = False---- | Explicit "type-class"-like dictionary for numeric primops------ Depends on Platform because creating a literal value depends on Platform-data PrimOps = PrimOps-   { add :: CoreExpr -> CoreExpr -> CoreExpr -- ^ Add two numbers-   , sub :: CoreExpr -> CoreExpr -> CoreExpr -- ^ Sub two numbers-   , mul :: CoreExpr -> CoreExpr -> CoreExpr -- ^ Multiply two numbers-   , mkL :: Integer -> CoreExpr              -- ^ Create a literal value-   }--intPrimOps :: Platform -> PrimOps-intPrimOps platform = PrimOps-   { add = \x y -> BinOpApp x IntAddOp y-   , sub = \x y -> BinOpApp x IntSubOp y-   , mul = \x y -> BinOpApp x IntMulOp y-   , mkL = intResult' platform-   }--wordPrimOps :: Platform -> PrimOps-wordPrimOps platform = PrimOps-   { add = \x y -> BinOpApp x WordAddOp y-   , sub = \x y -> BinOpApp x WordSubOp y-   , mul = \x y -> BinOpApp x WordMulOp y-   , mkL = wordResult' platform-   }-------------------------------------------------------------- Constant folding through case-expressions------ cf Scrutinee Constant Folding in simplCore/GHC.Core.Op.Simplify.Utils------------------------------------------------------------- | Match the scrutinee of a case and potentially return a new scrutinee and a--- function to apply to each literal alternative.-caseRules :: Platform-          -> CoreExpr                       -- Scrutinee-          -> Maybe ( CoreExpr               -- New scrutinee-                   , AltCon -> Maybe AltCon -- How to fix up the alt pattern-                                            --   Nothing <=> Unreachable-                                            -- See Note [Unreachable caseRules alternatives]-                   , Id -> CoreExpr)        -- How to reconstruct the original scrutinee-                                            -- from the new case-binder--- e.g  case e of b {---         ...;---         con bs -> rhs;---         ... }---  ==>---      case e' of b' {---         ...;---         fixup_altcon[con] bs -> let b = mk_orig[b] in rhs;---         ... }--caseRules platform (App (App (Var f) v) (Lit l))   -- v `op` x#-  | Just op <- isPrimOpId_maybe f-  , Just x  <- isLitValue_maybe l-  , Just adjust_lit <- adjustDyadicRight op x-  = Just (v, tx_lit_con platform adjust_lit-           , \v -> (App (App (Var f) (Var v)) (Lit l)))--caseRules platform (App (App (Var f) (Lit l)) v)   -- x# `op` v-  | Just op <- isPrimOpId_maybe f-  , Just x  <- isLitValue_maybe l-  , Just adjust_lit <- adjustDyadicLeft x op-  = Just (v, tx_lit_con platform adjust_lit-           , \v -> (App (App (Var f) (Lit l)) (Var v)))---caseRules platform (App (Var f) v              )   -- op v-  | Just op <- isPrimOpId_maybe f-  , Just adjust_lit <- adjustUnary op-  = Just (v, tx_lit_con platform adjust_lit-           , \v -> App (Var f) (Var v))---- See Note [caseRules for tagToEnum]-caseRules platform (App (App (Var f) type_arg) v)-  | Just TagToEnumOp <- isPrimOpId_maybe f-  = Just (v, tx_con_tte platform-           , \v -> (App (App (Var f) type_arg) (Var v)))---- See Note [caseRules for dataToTag]-caseRules _ (App (App (Var f) (Type ty)) v)       -- dataToTag x-  | Just DataToTagOp <- isPrimOpId_maybe f-  , Just (tc, _) <- tcSplitTyConApp_maybe ty-  , isAlgTyCon tc-  = Just (v, tx_con_dtt ty-           , \v -> App (App (Var f) (Type ty)) (Var v))--caseRules _ _ = Nothing---tx_lit_con :: Platform -> (Integer -> Integer) -> AltCon -> Maybe AltCon-tx_lit_con _        _      DEFAULT    = Just DEFAULT-tx_lit_con platform adjust (LitAlt l) = Just $ LitAlt (mapLitValue platform adjust l)-tx_lit_con _        _      alt        = pprPanic "caseRules" (ppr alt)-   -- NB: mapLitValue uses mkLitIntWrap etc, to ensure that the-   -- literal alternatives remain in Word/Int target ranges-   -- (See Note [Word/Int underflow/overflow] in GHC.Types.Literal and #13172).--adjustDyadicRight :: PrimOp -> Integer -> Maybe (Integer -> Integer)--- Given (x `op` lit) return a function 'f' s.t.  f (x `op` lit) = x-adjustDyadicRight op lit-  = case op of-         WordAddOp -> Just (\y -> y-lit      )-         IntAddOp  -> Just (\y -> y-lit      )-         WordSubOp -> Just (\y -> y+lit      )-         IntSubOp  -> Just (\y -> y+lit      )-         XorOp     -> Just (\y -> y `xor` lit)-         XorIOp    -> Just (\y -> y `xor` lit)-         _         -> Nothing--adjustDyadicLeft :: Integer -> PrimOp -> Maybe (Integer -> Integer)--- Given (lit `op` x) return a function 'f' s.t.  f (lit `op` x) = x-adjustDyadicLeft lit op-  = case op of-         WordAddOp -> Just (\y -> y-lit      )-         IntAddOp  -> Just (\y -> y-lit      )-         WordSubOp -> Just (\y -> lit-y      )-         IntSubOp  -> Just (\y -> lit-y      )-         XorOp     -> Just (\y -> y `xor` lit)-         XorIOp    -> Just (\y -> y `xor` lit)-         _         -> Nothing---adjustUnary :: PrimOp -> Maybe (Integer -> Integer)--- Given (op x) return a function 'f' s.t.  f (op x) = x-adjustUnary op-  = case op of-         NotOp     -> Just (\y -> complement y)-         NotIOp    -> Just (\y -> complement y)-         IntNegOp  -> Just (\y -> negate y    )-         _         -> Nothing--tx_con_tte :: Platform -> AltCon -> Maybe AltCon-tx_con_tte _        DEFAULT         = Just DEFAULT-tx_con_tte _        alt@(LitAlt {}) = pprPanic "caseRules" (ppr alt)-tx_con_tte platform (DataAlt dc)  -- See Note [caseRules for tagToEnum]-  = Just $ LitAlt $ mkLitInt platform $ toInteger $ dataConTagZ dc--tx_con_dtt :: Type -> AltCon -> Maybe AltCon-tx_con_dtt _  DEFAULT = Just DEFAULT-tx_con_dtt ty (LitAlt (LitNumber LitNumInt i _))-   | tag >= 0-   , tag < n_data_cons-   = Just (DataAlt (data_cons !! tag))   -- tag is zero-indexed, as is (!!)-   | otherwise-   = Nothing-   where-     tag         = fromInteger i :: ConTagZ-     tc          = tyConAppTyCon ty-     n_data_cons = tyConFamilySize tc-     data_cons   = tyConDataCons tc--tx_con_dtt _ alt = pprPanic "caseRules" (ppr alt)---{- Note [caseRules for tagToEnum]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We want to transform-   case tagToEnum x of-     False -> e1-     True  -> e2-into-   case x of-     0# -> e1-     1# -> e2--This rule eliminates a lot of boilerplate. For-  if (x>y) then e2 else e1-we generate-  case tagToEnum (x ># y) of-    False -> e1-    True  -> e2-and it is nice to then get rid of the tagToEnum.--Beware (#14768): avoid the temptation to map constructor 0 to-DEFAULT, in the hope of getting this-  case (x ># y) of-    DEFAULT -> e1-    1#      -> e2-That fails utterly in the case of-   data Colour = Red | Green | Blue-   case tagToEnum x of-      DEFAULT -> e1-      Red     -> e2--We don't want to get this!-   case x of-      DEFAULT -> e1-      DEFAULT -> e2--Instead, we deal with turning one branch into DEFAULT in GHC.Core.Op.Simplify.Utils-(add_default in mkCase3).--Note [caseRules for dataToTag]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-See also Note [dataToTag#] in primpops.txt.pp--We want to transform-  case dataToTag x of-    DEFAULT -> e1-    1# -> e2-into-  case x of-    DEFAULT -> e1-    (:) _ _ -> e2--Note the need for some wildcard binders in-the 'cons' case.--For the time, we only apply this transformation when the type of `x` is a type-headed by a normal tycon. In particular, we do not apply this in the case of a-data family tycon, since that would require carefully applying coercion(s)-between the data family and the data family instance's representation type,-which caseRules isn't currently engineered to handle (#14680).--Note [Unreachable caseRules alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Take care if we see something like-  case dataToTag x of-    DEFAULT -> e1-    -1# -> e2-    100 -> e3-because there isn't a data constructor with tag -1 or 100. In this case the-out-of-range alternative is dead code -- we know the range of tags for x.--Hence caseRules returns (AltCon -> Maybe AltCon), with Nothing indicating-an alternative that is unreachable.--You may wonder how this can happen: check out #15436.--}
− compiler/GHC/Core/Op/Monad.hs 
@@ -1,828 +0,0 @@-{--(c) The AQUA Project, Glasgow University, 1993-1998---}--{-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveFunctor #-}--{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}--module GHC.Core.Op.Monad (-    -- * Configuration of the core-to-core passes-    CoreToDo(..), runWhen, runMaybe,-    SimplMode(..),-    FloatOutSwitches(..),-    pprPassDetails,--    -- * Plugins-    CorePluginPass, bindsOnlyPass,--    -- * Counting-    SimplCount, doSimplTick, doFreeSimplTick, simplCountN,-    pprSimplCount, plusSimplCount, zeroSimplCount,-    isZeroSimplCount, hasDetailedCounts, Tick(..),--    -- * The monad-    CoreM, runCoreM,--    -- ** Reading from the monad-    getHscEnv, getRuleBase, getModule,-    getDynFlags, getPackageFamInstEnv,-    getVisibleOrphanMods, getUniqMask,-    getPrintUnqualified, getSrcSpanM,--    -- ** Writing to the monad-    addSimplCount,--    -- ** Lifting into the monad-    liftIO, liftIOWithCount,--    -- ** Dealing with annotations-    getAnnotations, getFirstAnnotations,--    -- ** Screen output-    putMsg, putMsgS, errorMsg, errorMsgS, warnMsg,-    fatalErrorMsg, fatalErrorMsgS,-    debugTraceMsg, debugTraceMsgS,-    dumpIfSet_dyn-  ) where--import GhcPrelude hiding ( read )--import GHC.Core-import GHC.Driver.Types-import GHC.Types.Module-import GHC.Driver.Session-import GHC.Types.Basic  ( CompilerPhase(..) )-import GHC.Types.Annotations--import IOEnv hiding     ( liftIO, failM, failWithM )-import qualified IOEnv  ( liftIO )-import GHC.Types.Var-import Outputable-import FastString-import ErrUtils( Severity(..), DumpFormat (..), dumpOptionsFromFlag )-import GHC.Types.Unique.Supply-import MonadUtils-import GHC.Types.Name.Env-import GHC.Types.SrcLoc-import Data.Bifunctor ( bimap )-import ErrUtils (dumpAction)-import Data.List (intersperse, groupBy, sortBy)-import Data.Ord-import Data.Dynamic-import Data.Map (Map)-import qualified Data.Map as Map-import qualified Data.Map.Strict as MapStrict-import Data.Word-import Control.Monad-import Control.Applicative ( Alternative(..) )-import Panic (throwGhcException, GhcException(..))--{--************************************************************************-*                                                                      *-              The CoreToDo type and related types-          Abstraction of core-to-core passes to run.-*                                                                      *-************************************************************************--}--data CoreToDo           -- These are diff core-to-core passes,-                        -- which may be invoked in any order,-                        -- as many times as you like.--  = CoreDoSimplify      -- The core-to-core simplifier.-        Int                    -- Max iterations-        SimplMode-  | CoreDoPluginPass String CorePluginPass-  | CoreDoFloatInwards-  | CoreDoFloatOutwards FloatOutSwitches-  | CoreLiberateCase-  | CoreDoPrintCore-  | CoreDoStaticArgs-  | CoreDoCallArity-  | CoreDoExitify-  | CoreDoDemand-  | CoreDoCpr-  | CoreDoWorkerWrapper-  | CoreDoSpecialising-  | CoreDoSpecConstr-  | CoreCSE-  | CoreDoRuleCheck CompilerPhase String   -- Check for non-application of rules-                                           -- matching this string-  | CoreDoNothing                -- Useful when building up-  | CoreDoPasses [CoreToDo]      -- lists of these things--  | CoreDesugar    -- Right after desugaring, no simple optimisation yet!-  | CoreDesugarOpt -- CoreDesugarXXX: Not strictly a core-to-core pass, but produces-                       --                 Core output, and hence useful to pass to endPass--  | CoreTidy-  | CorePrep-  | CoreOccurAnal--instance Outputable CoreToDo where-  ppr (CoreDoSimplify _ _)     = text "Simplifier"-  ppr (CoreDoPluginPass s _)   = text "Core plugin: " <+> text s-  ppr CoreDoFloatInwards       = text "Float inwards"-  ppr (CoreDoFloatOutwards f)  = text "Float out" <> parens (ppr f)-  ppr CoreLiberateCase         = text "Liberate case"-  ppr CoreDoStaticArgs         = text "Static argument"-  ppr CoreDoCallArity          = text "Called arity analysis"-  ppr CoreDoExitify            = text "Exitification transformation"-  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"-  ppr CoreCSE                  = text "Common sub-expression"-  ppr CoreDesugar              = text "Desugar (before optimization)"-  ppr CoreDesugarOpt           = text "Desugar (after optimization)"-  ppr CoreTidy                 = text "Tidy Core"-  ppr CorePrep                 = text "CorePrep"-  ppr CoreOccurAnal            = text "Occurrence analysis"-  ppr CoreDoPrintCore          = text "Print core"-  ppr (CoreDoRuleCheck {})     = text "Rule check"-  ppr CoreDoNothing            = text "CoreDoNothing"-  ppr (CoreDoPasses passes)    = text "CoreDoPasses" <+> ppr passes--pprPassDetails :: CoreToDo -> SDoc-pprPassDetails (CoreDoSimplify n md) = vcat [ text "Max iterations =" <+> int n-                                            , ppr md ]-pprPassDetails _ = Outputable.empty--data SimplMode             -- See comments in GHC.Core.Op.Simplify.Monad-  = SimplMode-        { sm_names      :: [String] -- Name(s) of the phase-        , sm_phase      :: CompilerPhase-        , sm_dflags     :: DynFlags -- Just for convenient non-monadic-                                    -- access; we don't override these-        , sm_rules      :: Bool     -- Whether RULES are enabled-        , sm_inline     :: Bool     -- Whether inlining is enabled-        , sm_case_case  :: Bool     -- Whether case-of-case is enabled-        , sm_eta_expand :: Bool     -- Whether eta-expansion is enabled-        }--instance Outputable SimplMode where-    ppr (SimplMode { sm_phase = p, sm_names = ss-                   , sm_rules = r, sm_inline = i-                   , sm_eta_expand = eta, sm_case_case = cc })-       = text "SimplMode" <+> braces (-         sep [ text "Phase =" <+> ppr p <+>-               brackets (text (concat $ intersperse "," ss)) <> comma-             , pp_flag i   (sLit "inline") <> comma-             , pp_flag r   (sLit "rules") <> comma-             , pp_flag eta (sLit "eta-expand") <> comma-             , pp_flag cc  (sLit "case-of-case") ])-         where-           pp_flag f s = ppUnless f (text "no") <+> ptext s--data FloatOutSwitches = FloatOutSwitches {-  floatOutLambdas   :: Maybe Int,  -- ^ Just n <=> float lambdas to top level, if-                                   -- doing so will abstract over n or fewer-                                   -- value variables-                                   -- Nothing <=> float all lambdas to top level,-                                   --             regardless of how many free variables-                                   -- Just 0 is the vanilla case: float a lambda-                                   --    iff it has no free vars--  floatOutConstants :: Bool,       -- ^ True <=> float constants to top level,-                                   --            even if they do not escape a lambda-  floatOutOverSatApps :: Bool,-                             -- ^ True <=> float out over-saturated applications-                             --            based on arity information.-                             -- See Note [Floating over-saturated applications]-                             -- in GHC.Core.Op.SetLevels-  floatToTopLevelOnly :: Bool      -- ^ Allow floating to the top level only.-  }-instance Outputable FloatOutSwitches where-    ppr = pprFloatOutSwitches--pprFloatOutSwitches :: FloatOutSwitches -> SDoc-pprFloatOutSwitches sw-  = text "FOS" <+> (braces $-     sep $ punctuate comma $-     [ text "Lam ="    <+> ppr (floatOutLambdas sw)-     , text "Consts =" <+> ppr (floatOutConstants sw)-     , text "OverSatApps ="   <+> ppr (floatOutOverSatApps sw) ])---- The core-to-core pass ordering is derived from the DynFlags:-runWhen :: Bool -> CoreToDo -> CoreToDo-runWhen True  do_this = do_this-runWhen False _       = CoreDoNothing--runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo-runMaybe (Just x) f = f x-runMaybe Nothing  _ = CoreDoNothing--{---************************************************************************-*                                                                      *-             Types for Plugins-*                                                                      *-************************************************************************--}---- | A description of the plugin pass itself-type CorePluginPass = ModGuts -> CoreM ModGuts--bindsOnlyPass :: (CoreProgram -> CoreM CoreProgram) -> ModGuts -> CoreM ModGuts-bindsOnlyPass pass guts-  = do { binds' <- pass (mg_binds guts)-       ; return (guts { mg_binds = binds' }) }--{--************************************************************************-*                                                                      *-             Counting and logging-*                                                                      *-************************************************************************--}--getVerboseSimplStats :: (Bool -> SDoc) -> SDoc-getVerboseSimplStats = getPprDebug          -- For now, anyway--zeroSimplCount     :: DynFlags -> SimplCount-isZeroSimplCount   :: SimplCount -> Bool-hasDetailedCounts  :: SimplCount -> Bool-pprSimplCount      :: SimplCount -> SDoc-doSimplTick        :: DynFlags -> Tick -> SimplCount -> SimplCount-doFreeSimplTick    ::             Tick -> SimplCount -> SimplCount-plusSimplCount     :: SimplCount -> SimplCount -> SimplCount--data SimplCount-   = VerySimplCount !Int        -- Used when don't want detailed stats--   | SimplCount {-        ticks   :: !Int,        -- Total ticks-        details :: !TickCounts, -- How many of each type--        n_log   :: !Int,        -- N-        log1    :: [Tick],      -- Last N events; <= opt_HistorySize,-                                --   most recent first-        log2    :: [Tick]       -- Last opt_HistorySize events before that-                                -- Having log1, log2 lets us accumulate the-                                -- recent history reasonably efficiently-     }--type TickCounts = Map Tick Int--simplCountN :: SimplCount -> Int-simplCountN (VerySimplCount n)         = n-simplCountN (SimplCount { ticks = n }) = n--zeroSimplCount dflags-                -- This is where we decide whether to do-                -- the VerySimpl version or the full-stats version-  | dopt Opt_D_dump_simpl_stats dflags-  = SimplCount {ticks = 0, details = Map.empty,-                n_log = 0, log1 = [], log2 = []}-  | otherwise-  = VerySimplCount 0--isZeroSimplCount (VerySimplCount n)         = n==0-isZeroSimplCount (SimplCount { ticks = n }) = n==0--hasDetailedCounts (VerySimplCount {}) = False-hasDetailedCounts (SimplCount {})     = True--doFreeSimplTick tick sc@SimplCount { details = dts }-  = sc { details = dts `addTick` tick }-doFreeSimplTick _ sc = sc--doSimplTick dflags tick-    sc@(SimplCount { ticks = tks, details = dts, n_log = nl, log1 = l1 })-  | nl >= historySize dflags = sc1 { n_log = 1, log1 = [tick], log2 = l1 }-  | otherwise                = sc1 { n_log = nl+1, log1 = tick : l1 }-  where-    sc1 = sc { ticks = tks+1, details = dts `addTick` tick }--doSimplTick _ _ (VerySimplCount n) = VerySimplCount (n+1)---addTick :: TickCounts -> Tick -> TickCounts-addTick fm tick = MapStrict.insertWith (+) tick 1 fm--plusSimplCount sc1@(SimplCount { ticks = tks1, details = dts1 })-               sc2@(SimplCount { ticks = tks2, details = dts2 })-  = log_base { ticks = tks1 + tks2-             , details = MapStrict.unionWith (+) dts1 dts2 }-  where-        -- A hackish way of getting recent log info-    log_base | null (log1 sc2) = sc1    -- Nothing at all in sc2-             | null (log2 sc2) = sc2 { log2 = log1 sc1 }-             | otherwise       = sc2--plusSimplCount (VerySimplCount n) (VerySimplCount m) = VerySimplCount (n+m)-plusSimplCount lhs                rhs                =-  throwGhcException . PprProgramError "plusSimplCount" $ vcat-    [ text "lhs"-    , pprSimplCount lhs-    , text "rhs"-    , pprSimplCount rhs-    ]-       -- We use one or the other consistently--pprSimplCount (VerySimplCount n) = text "Total ticks:" <+> int n-pprSimplCount (SimplCount { ticks = tks, details = dts, log1 = l1, log2 = l2 })-  = vcat [text "Total ticks:    " <+> int tks,-          blankLine,-          pprTickCounts dts,-          getVerboseSimplStats $ \dbg -> if dbg-          then-                vcat [blankLine,-                      text "Log (most recent first)",-                      nest 4 (vcat (map ppr l1) $$ vcat (map ppr l2))]-          else Outputable.empty-    ]--{- Note [Which transformations are innocuous]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-At one point (Jun 18) I wondered if some transformations (ticks)-might be  "innocuous", in the sense that they do not unlock a later-transformation that does not occur in the same pass.  If so, we could-refrain from bumping the overall tick-count for such innocuous-transformations, and perhaps terminate the simplifier one pass-earlier.--But alas I found that virtually nothing was innocuous!  This Note-just records what I learned, in case anyone wants to try again.--These transformations are not innocuous:--*** NB: I think these ones could be made innocuous-          EtaExpansion-          LetFloatFromLet--LetFloatFromLet-    x = K (let z = e2 in Just z)-  prepareRhs transforms to-    x2 = let z=e2 in Just z-    x  = K xs-  And now more let-floating can happen in the-  next pass, on x2--PreInlineUnconditionally-  Example in spectral/cichelli/Auxil-     hinsert = ...let lo = e in-                  let j = ...lo... in-                  case x of-                    False -> ()-                    True -> case lo of I# lo' ->-                              ...j...-  When we PreInlineUnconditionally j, lo's occ-info changes to once,-  so it can be PreInlineUnconditionally in the next pass, and a-  cascade of further things can happen.--PostInlineUnconditionally-  let x = e in-  let y = ...x.. in-  case .. of { A -> ...x...y...-               B -> ...x...y... }-  Current postinlineUnconditinaly will inline y, and then x; sigh.--  But PostInlineUnconditionally might also unlock subsequent-  transformations for the same reason as PreInlineUnconditionally,-  so it's probably not innocuous anyway.--KnownBranch, BetaReduction:-  May drop chunks of code, and thereby enable PreInlineUnconditionally-  for some let-binding which now occurs once--EtaExpansion:-  Example in imaginary/digits-of-e1-    fail = \void. e          where e :: IO ()-  --> etaExpandRhs-    fail = \void. (\s. (e |> g) s) |> sym g      where g :: IO () ~ S -> (S,())-  --> Next iteration of simplify-    fail1 = \void. \s. (e |> g) s-    fail = fail1 |> Void#->sym g-  And now inline 'fail'--CaseMerge:-  case x of y {-    DEFAULT -> case y of z { pi -> ei }-    alts2 }-  ---> CaseMerge-    case x of { pi -> let z = y in ei-              ; alts2 }-  The "let z=y" case-binder-swap gets dealt with in the next pass--}--pprTickCounts :: Map Tick Int -> SDoc-pprTickCounts counts-  = vcat (map pprTickGroup groups)-  where-    groups :: [[(Tick,Int)]]    -- Each group shares a common tag-                                -- toList returns common tags adjacent-    groups = groupBy same_tag (Map.toList counts)-    same_tag (tick1,_) (tick2,_) = tickToTag tick1 == tickToTag tick2--pprTickGroup :: [(Tick, Int)] -> SDoc-pprTickGroup group@((tick1,_):_)-  = hang (int (sum [n | (_,n) <- group]) <+> text (tickString tick1))-       2 (vcat [ int n <+> pprTickCts tick-                                    -- flip as we want largest first-               | (tick,n) <- sortBy (flip (comparing snd)) group])-pprTickGroup [] = panic "pprTickGroup"--data Tick  -- See Note [Which transformations are innocuous]-  = PreInlineUnconditionally    Id-  | PostInlineUnconditionally   Id--  | UnfoldingDone               Id-  | RuleFired                   FastString      -- Rule name--  | LetFloatFromLet-  | EtaExpansion                Id      -- LHS binder-  | EtaReduction                Id      -- Binder on outer lambda-  | BetaReduction               Id      -- Lambda binder---  | CaseOfCase                  Id      -- Bndr on *inner* case-  | KnownBranch                 Id      -- Case binder-  | CaseMerge                   Id      -- Binder on outer case-  | AltMerge                    Id      -- Case binder-  | CaseElim                    Id      -- Case binder-  | CaseIdentity                Id      -- Case binder-  | FillInCaseDefault           Id      -- Case binder--  | SimplifierDone              -- Ticked at each iteration of the simplifier--instance Outputable Tick where-  ppr tick = text (tickString tick) <+> pprTickCts tick--instance Eq Tick where-  a == b = case a `cmpTick` b of-           EQ -> True-           _ -> False--instance Ord Tick where-  compare = cmpTick--tickToTag :: Tick -> Int-tickToTag (PreInlineUnconditionally _)  = 0-tickToTag (PostInlineUnconditionally _) = 1-tickToTag (UnfoldingDone _)             = 2-tickToTag (RuleFired _)                 = 3-tickToTag LetFloatFromLet               = 4-tickToTag (EtaExpansion _)              = 5-tickToTag (EtaReduction _)              = 6-tickToTag (BetaReduction _)             = 7-tickToTag (CaseOfCase _)                = 8-tickToTag (KnownBranch _)               = 9-tickToTag (CaseMerge _)                 = 10-tickToTag (CaseElim _)                  = 11-tickToTag (CaseIdentity _)              = 12-tickToTag (FillInCaseDefault _)         = 13-tickToTag SimplifierDone                = 16-tickToTag (AltMerge _)                  = 17--tickString :: Tick -> String-tickString (PreInlineUnconditionally _) = "PreInlineUnconditionally"-tickString (PostInlineUnconditionally _)= "PostInlineUnconditionally"-tickString (UnfoldingDone _)            = "UnfoldingDone"-tickString (RuleFired _)                = "RuleFired"-tickString LetFloatFromLet              = "LetFloatFromLet"-tickString (EtaExpansion _)             = "EtaExpansion"-tickString (EtaReduction _)             = "EtaReduction"-tickString (BetaReduction _)            = "BetaReduction"-tickString (CaseOfCase _)               = "CaseOfCase"-tickString (KnownBranch _)              = "KnownBranch"-tickString (CaseMerge _)                = "CaseMerge"-tickString (AltMerge _)                 = "AltMerge"-tickString (CaseElim _)                 = "CaseElim"-tickString (CaseIdentity _)             = "CaseIdentity"-tickString (FillInCaseDefault _)        = "FillInCaseDefault"-tickString SimplifierDone               = "SimplifierDone"--pprTickCts :: Tick -> SDoc-pprTickCts (PreInlineUnconditionally v) = ppr v-pprTickCts (PostInlineUnconditionally v)= ppr v-pprTickCts (UnfoldingDone v)            = ppr v-pprTickCts (RuleFired v)                = ppr v-pprTickCts LetFloatFromLet              = Outputable.empty-pprTickCts (EtaExpansion v)             = ppr v-pprTickCts (EtaReduction v)             = ppr v-pprTickCts (BetaReduction v)            = ppr v-pprTickCts (CaseOfCase v)               = ppr v-pprTickCts (KnownBranch v)              = ppr v-pprTickCts (CaseMerge v)                = ppr v-pprTickCts (AltMerge v)                 = ppr v-pprTickCts (CaseElim v)                 = ppr v-pprTickCts (CaseIdentity v)             = ppr v-pprTickCts (FillInCaseDefault v)        = ppr v-pprTickCts _                            = Outputable.empty--cmpTick :: Tick -> Tick -> Ordering-cmpTick a b = case (tickToTag a `compare` tickToTag b) of-                GT -> GT-                EQ -> cmpEqTick a b-                LT -> LT--cmpEqTick :: Tick -> Tick -> Ordering-cmpEqTick (PreInlineUnconditionally a)  (PreInlineUnconditionally b)    = a `compare` b-cmpEqTick (PostInlineUnconditionally a) (PostInlineUnconditionally b)   = a `compare` b-cmpEqTick (UnfoldingDone a)             (UnfoldingDone b)               = a `compare` b-cmpEqTick (RuleFired a)                 (RuleFired b)                   = a `compare` b-cmpEqTick (EtaExpansion a)              (EtaExpansion b)                = a `compare` b-cmpEqTick (EtaReduction a)              (EtaReduction b)                = a `compare` b-cmpEqTick (BetaReduction a)             (BetaReduction b)               = a `compare` b-cmpEqTick (CaseOfCase a)                (CaseOfCase b)                  = a `compare` b-cmpEqTick (KnownBranch a)               (KnownBranch b)                 = a `compare` b-cmpEqTick (CaseMerge a)                 (CaseMerge b)                   = a `compare` b-cmpEqTick (AltMerge a)                  (AltMerge b)                    = a `compare` b-cmpEqTick (CaseElim a)                  (CaseElim b)                    = a `compare` b-cmpEqTick (CaseIdentity a)              (CaseIdentity b)                = a `compare` b-cmpEqTick (FillInCaseDefault a)         (FillInCaseDefault b)           = a `compare` b-cmpEqTick _                             _                               = EQ--{--************************************************************************-*                                                                      *-             Monad and carried data structure definitions-*                                                                      *-************************************************************************--}--data CoreReader = CoreReader {-        cr_hsc_env             :: HscEnv,-        cr_rule_base           :: RuleBase,-        cr_module              :: Module,-        cr_print_unqual        :: PrintUnqualified,-        cr_loc                 :: SrcSpan,   -- Use this for log/error messages so they-                                             -- are at least tagged with the right source file-        cr_visible_orphan_mods :: !ModuleSet,-        cr_uniq_mask           :: !Char      -- Mask for creating unique values-}---- Note: CoreWriter used to be defined with data, rather than newtype.  If it--- is defined that way again, the cw_simpl_count field, at least, must be--- strict to avoid a space leak (#7702).-newtype CoreWriter = CoreWriter {-        cw_simpl_count :: SimplCount-}--emptyWriter :: DynFlags -> CoreWriter-emptyWriter dflags = CoreWriter {-        cw_simpl_count = zeroSimplCount dflags-    }--plusWriter :: CoreWriter -> CoreWriter -> CoreWriter-plusWriter w1 w2 = CoreWriter {-        cw_simpl_count = (cw_simpl_count w1) `plusSimplCount` (cw_simpl_count w2)-    }--type CoreIOEnv = IOEnv CoreReader---- | The monad used by Core-to-Core passes to register simplification statistics.---  Also used to have common state (in the form of UniqueSupply) for generating Uniques.-newtype CoreM a = CoreM { unCoreM :: CoreIOEnv (a, CoreWriter) }-    deriving (Functor)--instance Monad CoreM where-    mx >>= f = CoreM $ do-            (x, w1) <- unCoreM mx-            (y, w2) <- unCoreM (f x)-            let w = w1 `plusWriter` w2-            return $ seq w (y, w)-            -- forcing w before building the tuple avoids a space leak-            -- (#7702)--instance Applicative CoreM where-    pure x = CoreM $ nop x-    (<*>) = ap-    m *> k = m >>= \_ -> k--instance Alternative CoreM where-    empty   = CoreM Control.Applicative.empty-    m <|> n = CoreM (unCoreM m <|> unCoreM n)--instance MonadPlus CoreM--instance MonadUnique CoreM where-    getUniqueSupplyM = do-        mask <- read cr_uniq_mask-        liftIO $! mkSplitUniqSupply mask--    getUniqueM = do-        mask <- read cr_uniq_mask-        liftIO $! uniqFromMask mask--runCoreM :: HscEnv-         -> RuleBase-         -> Char -- ^ Mask-         -> Module-         -> ModuleSet-         -> PrintUnqualified-         -> SrcSpan-         -> CoreM a-         -> IO (a, SimplCount)-runCoreM hsc_env rule_base mask mod orph_imps print_unqual loc m-  = liftM extract $ runIOEnv reader $ unCoreM m-  where-    reader = CoreReader {-            cr_hsc_env = hsc_env,-            cr_rule_base = rule_base,-            cr_module = mod,-            cr_visible_orphan_mods = orph_imps,-            cr_print_unqual = print_unqual,-            cr_loc = loc,-            cr_uniq_mask = mask-        }--    extract :: (a, CoreWriter) -> (a, SimplCount)-    extract (value, writer) = (value, cw_simpl_count writer)--{--************************************************************************-*                                                                      *-             Core combinators, not exported-*                                                                      *-************************************************************************--}--nop :: a -> CoreIOEnv (a, CoreWriter)-nop x = do-    r <- getEnv-    return (x, emptyWriter $ (hsc_dflags . cr_hsc_env) r)--read :: (CoreReader -> a) -> CoreM a-read f = CoreM $ getEnv >>= (\r -> nop (f r))--write :: CoreWriter -> CoreM ()-write w = CoreM $ return ((), w)---- \subsection{Lifting IO into the monad}---- | Lift an 'IOEnv' operation into 'CoreM'-liftIOEnv :: CoreIOEnv a -> CoreM a-liftIOEnv mx = CoreM (mx >>= (\x -> nop x))--instance MonadIO CoreM where-    liftIO = liftIOEnv . IOEnv.liftIO---- | Lift an 'IO' operation into 'CoreM' while consuming its 'SimplCount'-liftIOWithCount :: IO (SimplCount, a) -> CoreM a-liftIOWithCount what = liftIO what >>= (\(count, x) -> addSimplCount count >> return x)--{--************************************************************************-*                                                                      *-             Reader, writer and state accessors-*                                                                      *-************************************************************************--}--getHscEnv :: CoreM HscEnv-getHscEnv = read cr_hsc_env--getRuleBase :: CoreM RuleBase-getRuleBase = read cr_rule_base--getVisibleOrphanMods :: CoreM ModuleSet-getVisibleOrphanMods = read cr_visible_orphan_mods--getPrintUnqualified :: CoreM PrintUnqualified-getPrintUnqualified = read cr_print_unqual--getSrcSpanM :: CoreM SrcSpan-getSrcSpanM = read cr_loc--addSimplCount :: SimplCount -> CoreM ()-addSimplCount count = write (CoreWriter { cw_simpl_count = count })--getUniqMask :: CoreM Char-getUniqMask = read cr_uniq_mask---- Convenience accessors for useful fields of HscEnv--instance HasDynFlags CoreM where-    getDynFlags = fmap hsc_dflags getHscEnv--instance HasModule CoreM where-    getModule = read cr_module--getPackageFamInstEnv :: CoreM PackageFamInstEnv-getPackageFamInstEnv = do-    hsc_env <- getHscEnv-    eps <- liftIO $ hscEPS hsc_env-    return $ eps_fam_inst_env eps--{--************************************************************************-*                                                                      *-             Dealing with annotations-*                                                                      *-************************************************************************--}---- | Get all annotations of a given type. This happens lazily, that is--- no deserialization will take place until the [a] is actually demanded and--- the [a] can also be empty (the UniqFM is not filtered).------ This should be done once at the start of a Core-to-Core pass that uses--- annotations.------ See Note [Annotations]-getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv [a], NameEnv [a])-getAnnotations deserialize guts = do-     hsc_env <- getHscEnv-     ann_env <- liftIO $ prepareAnnotations hsc_env (Just guts)-     return (deserializeAnns deserialize ann_env)---- | Get at most one annotation of a given type per annotatable item.-getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv a, NameEnv a)-getFirstAnnotations deserialize guts-  = bimap mod name <$> getAnnotations deserialize guts-  where-    mod = mapModuleEnv head . filterModuleEnv (const $ not . null)-    name = mapNameEnv head . filterNameEnv (not . null)--{--Note [Annotations]-~~~~~~~~~~~~~~~~~~-A Core-to-Core pass that wants to make use of annotations calls-getAnnotations or getFirstAnnotations at the beginning to obtain a UniqFM with-annotations of a specific type. This produces all annotations from interface-files read so far. However, annotations from interface files read during the-pass will not be visible until getAnnotations is called again. This is similar-to how rules work and probably isn't too bad.--The current implementation could be optimised a bit: when looking up-annotations for a thing from the HomePackageTable, we could search directly in-the module where the thing is defined rather than building one UniqFM which-contains all annotations we know of. This would work because annotations can-only be given to things defined in the same module. However, since we would-only want to deserialise every annotation once, we would have to build a cache-for every module in the HTP. In the end, it's probably not worth it as long as-we aren't using annotations heavily.--************************************************************************-*                                                                      *-                Direct screen output-*                                                                      *-************************************************************************--}--msg :: Severity -> WarnReason -> SDoc -> CoreM ()-msg sev reason doc-  = do { dflags <- getDynFlags-       ; loc    <- getSrcSpanM-       ; unqual <- getPrintUnqualified-       ; let sty = case sev of-                     SevError   -> err_sty-                     SevWarning -> err_sty-                     SevDump    -> dump_sty-                     _          -> user_sty-             err_sty  = mkErrStyle dflags unqual-             user_sty = mkUserStyle dflags unqual AllTheWay-             dump_sty = mkDumpStyle dflags unqual-       ; liftIO $ putLogMsg dflags reason sev loc sty doc }---- | Output a String message to the screen-putMsgS :: String -> CoreM ()-putMsgS = putMsg . text---- | Output a message to the screen-putMsg :: SDoc -> CoreM ()-putMsg = msg SevInfo NoReason---- | Output an error to the screen. Does not cause the compiler to die.-errorMsgS :: String -> CoreM ()-errorMsgS = errorMsg . text---- | Output an error to the screen. Does not cause the compiler to die.-errorMsg :: SDoc -> CoreM ()-errorMsg = msg SevError NoReason--warnMsg :: WarnReason -> SDoc -> CoreM ()-warnMsg = msg SevWarning---- | Output a fatal error to the screen. Does not cause the compiler to die.-fatalErrorMsgS :: String -> CoreM ()-fatalErrorMsgS = fatalErrorMsg . text---- | Output a fatal error to the screen. Does not cause the compiler to die.-fatalErrorMsg :: SDoc -> CoreM ()-fatalErrorMsg = msg SevFatal NoReason---- | Output a string debugging message at verbosity level of @-v@ or higher-debugTraceMsgS :: String -> CoreM ()-debugTraceMsgS = debugTraceMsg . text---- | Outputs a debugging message at verbosity level of @-v@ or higher-debugTraceMsg :: SDoc -> CoreM ()-debugTraceMsg = msg SevDump NoReason---- | Show some labelled 'SDoc' if a particular flag is set or at a verbosity level of @-v -ddump-most@ or higher-dumpIfSet_dyn :: DumpFlag -> String -> DumpFormat -> SDoc -> CoreM ()-dumpIfSet_dyn flag str fmt doc-  = do { dflags <- getDynFlags-       ; unqual <- getPrintUnqualified-       ; when (dopt flag dflags) $ liftIO $ do-         let sty = mkDumpStyle dflags unqual-         dumpAction dflags sty (dumpOptionsFromFlag flag) str fmt doc }
− compiler/GHC/Core/Op/Monad.hs-boot 
@@ -1,30 +0,0 @@--- Created this hs-boot file to remove circular dependencies from the use of--- Plugins. Plugins needs CoreToDo and CoreM types to define core-to-core--- transformations.--- However GHC.Core.Op.Monad does much more than defining these, and because Plugins are--- activated in various modules, the imports become circular. To solve this I--- extracted CoreToDo and CoreM into this file.--- I needed to write the whole definition of these types, otherwise it created--- a data-newtype conflict.--module GHC.Core.Op.Monad ( CoreToDo, CoreM ) where--import GhcPrelude--import IOEnv ( IOEnv )--type CoreIOEnv = IOEnv CoreReader--data CoreReader--newtype CoreWriter = CoreWriter {-        cw_simpl_count :: SimplCount-}--data SimplCount--newtype CoreM a = CoreM { unCoreM :: CoreIOEnv (a, CoreWriter) }--instance Monad CoreM--data CoreToDo
− compiler/GHC/Core/Op/OccurAnal.hs 
@@ -1,2898 +0,0 @@-{--(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--************************************************************************-*                                                                      *-\section[OccurAnal]{Occurrence analysis pass}-*                                                                      *-************************************************************************--The occurrence analyser re-typechecks a core expression, returning a new-core expression with (hopefully) improved usage information.--}--{-# LANGUAGE CPP, BangPatterns, MultiWayIf, ViewPatterns  #-}--{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}--module GHC.Core.Op.OccurAnal (-        occurAnalysePgm, occurAnalyseExpr, occurAnalyseExpr_NoBinderSwap-    ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.Core-import GHC.Core.FVs-import GHC.Core.Utils   ( exprIsTrivial, isDefaultAlt, isExpandableApp,-                          stripTicksTopE, mkTicks )-import GHC.Core.Arity   ( joinRhsArity )-import GHC.Types.Id-import GHC.Types.Id.Info-import GHC.Types.Name( localiseName )-import GHC.Types.Basic-import GHC.Types.Module( Module )-import GHC.Core.Coercion-import GHC.Core.Type--import GHC.Types.Var.Set-import GHC.Types.Var.Env-import GHC.Types.Var-import GHC.Types.Demand ( argOneShots, argsOneShots )-import Digraph          ( SCC(..), Node(..)-                        , stronglyConnCompFromEdgedVerticesUniq-                        , stronglyConnCompFromEdgedVerticesUniqR )-import GHC.Types.Unique-import GHC.Types.Unique.FM-import GHC.Types.Unique.Set-import Util-import Outputable-import Data.List-import Control.Arrow    ( second )--{--************************************************************************-*                                                                      *-    occurAnalysePgm, occurAnalyseExpr, occurAnalyseExpr_NoBinderSwap-*                                                                      *-************************************************************************--Here's the externally-callable interface:--}--occurAnalysePgm :: Module         -- Used only in debug output-                -> (Id -> Bool)         -- Active unfoldings-                -> (Activation -> Bool) -- Active rules-                -> [CoreRule]-                -> CoreProgram -> CoreProgram-occurAnalysePgm this_mod active_unf active_rule imp_rules binds-  | isEmptyDetails final_usage-  = occ_anald_binds--  | otherwise   -- See Note [Glomming]-  = WARN( True, hang (text "Glomming in" <+> ppr this_mod <> colon)-                   2 (ppr final_usage ) )-    occ_anald_glommed_binds-  where-    init_env = initOccEnv { occ_rule_act = active_rule-                          , occ_unf_act  = active_unf }--    (final_usage, occ_anald_binds) = go init_env binds-    (_, occ_anald_glommed_binds)   = occAnalRecBind init_env TopLevel-                                                    imp_rule_edges-                                                    (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)-    -- The RULES declarations keep things alive!--    -- Note [Preventing loops due to imported functions rules]-    imp_rule_edges = foldr (plusVarEnv_C unionVarSet) emptyVarEnv-                            [ mapVarEnv (const maps_to) $-                                getUniqSet (exprFreeIds arg `delVarSetList` ru_bndrs imp_rule)-                            | imp_rule <- imp_rules-                            , not (isBuiltinRule imp_rule)  -- See Note [Plugin rules]-                            , let maps_to = exprFreeIds (ru_rhs imp_rule)-                                             `delVarSetList` ru_bndrs imp_rule-                            , arg <- ru_args imp_rule ]--    go :: OccEnv -> [CoreBind] -> (UsageDetails, [CoreBind])-    go _ []-        = (initial_uds, [])-    go env (bind:binds)-        = (final_usage, bind' ++ binds')-        where-           (bs_usage, binds')   = go env binds-           (final_usage, bind') = occAnalBind env TopLevel imp_rule_edges bind-                                              bs_usage--occurAnalyseExpr :: CoreExpr -> CoreExpr-        -- Do occurrence analysis, and discard occurrence info returned-occurAnalyseExpr = occurAnalyseExpr' True -- do binder swap--occurAnalyseExpr_NoBinderSwap :: CoreExpr -> CoreExpr-occurAnalyseExpr_NoBinderSwap = occurAnalyseExpr' False -- do not do binder swap--occurAnalyseExpr' :: Bool -> CoreExpr -> CoreExpr-occurAnalyseExpr' enable_binder_swap expr-  = snd (occAnal env expr)-  where-    env = initOccEnv { occ_binder_swap = enable_binder_swap }--{- Note [Plugin rules]-~~~~~~~~~~~~~~~~~~~~~~-Conal Elliott (#11651) built a GHC plugin that added some-BuiltinRules (for imported Ids) to the mg_rules field of ModGuts, to-do some domain-specific transformations that could not be expressed-with an ordinary pattern-matching CoreRule.  But then we can't extract-the dependencies (in imp_rule_edges) from ru_rhs etc, because a-BuiltinRule doesn't have any of that stuff.--So we simply assume that BuiltinRules have no dependencies, and filter-them out from the imp_rule_edges comprehension.--}--{--************************************************************************-*                                                                      *-                Bindings-*                                                                      *-************************************************************************--Note [Recursive bindings: the grand plan]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we come across a binding group-  Rec { x1 = r1; ...; xn = rn }-we treat it like this (occAnalRecBind):--1. Occurrence-analyse each right hand side, and build a-   "Details" for each binding to capture the results.--   Wrap the details in a Node (details, node-id, dep-node-ids),-   where node-id is just the unique of the binder, and-   dep-node-ids lists all binders on which this binding depends.-   We'll call these the "scope edges".-   See Note [Forming the Rec groups].--   All this is done by makeNode.--2. Do SCC-analysis on these Nodes.  Each SCC will become a new Rec or-   NonRec.  The key property is that every free variable of a binding-   is accounted for by the scope edges, so that when we are done-   everything is still in scope.--3. For each Cyclic SCC of the scope-edge SCC-analysis in (2), we-   identify suitable loop-breakers to ensure that inlining terminates.-   This is done by occAnalRec.--4. To do so we form a new set of Nodes, with the same details, but-   different edges, the "loop-breaker nodes". The loop-breaker nodes-   have both more and fewer dependencies than the scope edges-   (see Note [Choosing loop breakers])--   More edges: if f calls g, and g has an active rule that mentions h-               then we add an edge from f -> h--   Fewer edges: we only include dependencies on active rules, on rule-                RHSs (not LHSs) and if there is an INLINE pragma only-                on the stable unfolding (and vice versa).  The scope-                edges must be much more inclusive.--5.  The "weak fvs" of a node are, by definition:-       the scope fvs - the loop-breaker fvs-    See Note [Weak loop breakers], and the nd_weak field of Details--6.  Having formed the loop-breaker nodes--Note [Dead code]-~~~~~~~~~~~~~~~~-Dropping dead code for a cyclic Strongly Connected Component is done-in a very simple way:--        the entire SCC is dropped if none of its binders are mentioned-        in the body; otherwise the whole thing is kept.--The key observation is that dead code elimination happens after-dependency analysis: so 'occAnalBind' processes SCCs instead of the-original term's binding groups.--Thus 'occAnalBind' does indeed drop 'f' in an example like--        letrec f = ...g...-               g = ...(...g...)...-        in-           ...g...--when 'g' no longer uses 'f' at all (eg 'f' does not occur in a RULE in-'g'). 'occAnalBind' first consumes 'CyclicSCC g' and then it consumes-'AcyclicSCC f', where 'body_usage' won't contain 'f'.---------------------------------------------------------------Note [Forming Rec groups]-~~~~~~~~~~~~~~~~~~~~~~~~~-We put bindings {f = ef; g = eg } in a Rec group if "f uses g"-and "g uses f", no matter how indirectly.  We do a SCC analysis-with an edge f -> g if "f uses g".--More precisely, "f uses g" iff g should be in scope wherever f is.-That is, g is free in:-  a) the rhs 'ef'-  b) or the RHS of a rule for f (Note [Rules are extra RHSs])-  c) or the LHS or a rule for f (Note [Rule dependency info])--These conditions apply regardless of the activation of the RULE (eg it might be-inactive in this phase but become active later).  Once a Rec is broken up-it can never be put back together, so we must be conservative.--The principle is that, regardless of rule firings, every variable is-always in scope.--  * Note [Rules are extra RHSs]-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~-    A RULE for 'f' is like an extra RHS for 'f'. That way the "parent"-    keeps the specialised "children" alive.  If the parent dies-    (because it isn't referenced any more), then the children will die-    too (unless they are already referenced directly).--    To that end, we build a Rec group for each cyclic strongly-    connected component,-        *treating f's rules as extra RHSs for 'f'*.-    More concretely, the SCC analysis runs on a graph with an edge-    from f -> g iff g is mentioned in-        (a) f's rhs-        (b) f's RULES-    These are rec_edges.--    Under (b) we include variables free in *either* LHS *or* RHS of-    the rule.  The former might seems silly, but see Note [Rule-    dependency info].  So in Example [eftInt], eftInt and eftIntFB-    will be put in the same Rec, even though their 'main' RHSs are-    both non-recursive.--  * Note [Rule dependency info]-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~-    The VarSet in a RuleInfo is used for dependency analysis in the-    occurrence analyser.  We must track free vars in *both* lhs and rhs.-    Hence use of idRuleVars, rather than idRuleRhsVars in occAnalBind.-    Why both? Consider-        x = y-        RULE f x = v+4-    Then if we substitute y for x, we'd better do so in the-    rule's LHS too, so we'd better ensure the RULE appears to mention 'x'-    as well as 'v'--  * Note [Rules are visible in their own rec group]-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-    We want the rules for 'f' to be visible in f's right-hand side.-    And we'd like them to be visible in other functions in f's Rec-    group.  E.g. in Note [Specialisation rules] we want f' rule-    to be visible in both f's RHS, and fs's RHS.--    This means that we must simplify the RULEs first, before looking-    at any of the definitions.  This is done by Simplify.simplRecBind,-    when it calls addLetIdInfo.---------------------------------------------------------------Note [Choosing loop breakers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Loop breaking is surprisingly subtle.  First read the section 4 of-"Secrets of the GHC inliner".  This describes our basic plan.-We avoid infinite inlinings by choosing loop breakers, and-ensuring that a loop breaker cuts each loop.--See also Note [Inlining and hs-boot files] in GHC.Core.ToIface, which-deals with a closely related source of infinite loops.--Fundamentally, we do SCC analysis on a graph.  For each recursive-group we choose a loop breaker, delete all edges to that node,-re-analyse the SCC, and iterate.--But what is the graph?  NOT the same graph as was used for Note-[Forming Rec groups]!  In particular, a RULE is like an equation for-'f' that is *always* inlined if it is applicable.  We do *not* disable-rules for loop-breakers.  It's up to whoever makes the rules to make-sure that the rules themselves always terminate.  See Note [Rules for-recursive functions] in GHC.Core.Op.Simplify--Hence, if-    f's RHS (or its INLINE template if it has one) mentions g, and-    g has a RULE that mentions h, and-    h has a RULE that mentions f--then we *must* choose f to be a loop breaker.  Example: see Note-[Specialisation rules].--In general, take the free variables of f's RHS, and augment it with-all the variables reachable by RULES from those starting points.  That-is the whole reason for computing rule_fv_env in occAnalBind.  (Of-course we only consider free vars that are also binders in this Rec-group.)  See also Note [Finding rule RHS free vars]--Note that when we compute this rule_fv_env, we only consider variables-free in the *RHS* of the rule, in contrast to the way we build the-Rec group in the first place (Note [Rule dependency info])--Note that if 'g' has RHS that mentions 'w', we should add w to-g's loop-breaker edges.  More concretely there is an edge from f -> g-iff-        (a) g is mentioned in f's RHS `xor` f's INLINE rhs-            (see Note [Inline rules])-        (b) or h is mentioned in f's RHS, and-            g appears in the RHS of an active RULE of h-            or a transitive sequence of active rules starting with h--Why "active rules"?  See Note [Finding rule RHS free vars]--Note that in Example [eftInt], *neither* eftInt *nor* eftIntFB is-chosen as a loop breaker, because their RHSs don't mention each other.-And indeed both can be inlined safely.--Note again that the edges of the graph we use for computing loop breakers-are not the same as the edges we use for computing the Rec blocks.-That's why we compute--- rec_edges          for the Rec block analysis-- loop_breaker_nodes for the loop breaker analysis--  * Note [Finding rule RHS free vars]-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-    Consider this real example from Data Parallel Haskell-         tagZero :: Array Int -> Array Tag-         {-# INLINE [1] tagZeroes #-}-         tagZero xs = pmap (\x -> fromBool (x==0)) xs--         {-# RULES "tagZero" [~1] forall xs n.-             pmap fromBool <blah blah> = tagZero xs #-}-    So tagZero's RHS mentions pmap, and pmap's RULE mentions tagZero.-    However, tagZero can only be inlined in phase 1 and later, while-    the RULE is only active *before* phase 1.  So there's no problem.--    To make this work, we look for the RHS free vars only for-    *active* rules. That's the reason for the occ_rule_act field-    of the OccEnv.--  * Note [Weak loop breakers]-    ~~~~~~~~~~~~~~~~~~~~~~~~~-    There is a last nasty wrinkle.  Suppose we have--        Rec { f = f_rhs-              RULE f [] = g--              h = h_rhs-              g = h-              ...more...-        }--    Remember that we simplify the RULES before any RHS (see Note-    [Rules are visible in their own rec group] above).--    So we must *not* postInlineUnconditionally 'g', even though-    its RHS turns out to be trivial.  (I'm assuming that 'g' is-    not chosen as a loop breaker.)  Why not?  Because then we-    drop the binding for 'g', which leaves it out of scope in the-    RULE!--    Here's a somewhat different example of the same thing-        Rec { g = h-            ; h = ...f...-            ; f = f_rhs-              RULE f [] = g }-    Here the RULE is "below" g, but we *still* can't postInlineUnconditionally-    g, because the RULE for f is active throughout.  So the RHS of h-    might rewrite to     h = ...g...-    So g must remain in scope in the output program!--    We "solve" this by:--        Make g a "weak" loop breaker (OccInfo = IAmLoopBreaker True)-        iff g is a "missing free variable" of the Rec group--    A "missing free variable" x is one that is mentioned in an RHS or-    INLINE or RULE of a binding in the Rec group, but where the-    dependency on x may not show up in the loop_breaker_nodes (see-    note [Choosing loop breakers} above).--    A normal "strong" loop breaker has IAmLoopBreaker False.  So--                                    Inline  postInlineUnconditionally-   strong   IAmLoopBreaker False    no      no-   weak     IAmLoopBreaker True     yes     no-            other                   yes     yes--    The **sole** reason for this kind of loop breaker is so that-    postInlineUnconditionally does not fire.  Ugh.  (Typically it'll-    inline via the usual callSiteInline stuff, so it'll be dead in the-    next pass, so the main Ugh is the tiresome complication.)--Note [Rules for imported functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this-   f = /\a. B.g a-   RULE B.g Int = 1 + f Int-Note that-  * The RULE is for an imported function.-  * f is non-recursive-Now we-can get-   f Int --> B.g Int      Inlining f-         --> 1 + f Int    Firing RULE-and so the simplifier goes into an infinite loop. This-would not happen if the RULE was for a local function,-because we keep track of dependencies through rules.  But-that is pretty much impossible to do for imported Ids.  Suppose-f's definition had been-   f = /\a. C.h a-where (by some long and devious process), C.h eventually inlines to-B.g.  We could only spot such loops by exhaustively following-unfoldings of C.h etc, in case we reach B.g, and hence (via the RULE)-f.--Note that RULES for imported functions are important in practice; they-occur a lot in the libraries.--We regard this potential infinite loop as a *programmer* error.-It's up the programmer not to write silly rules like-     RULE f x = f x-and the example above is just a more complicated version.--Note [Preventing loops due to imported functions rules]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider:-  import GHC.Base (foldr)--  {-# RULES "filterList" forall p. foldr (filterFB (:) p) [] = filter p #-}-  filter p xs = build (\c n -> foldr (filterFB c p) n xs)-  filterFB c p = ...--  f = filter p xs--Note that filter is not a loop-breaker, so what happens is:-  f =          filter p xs-    = {inline} build (\c n -> foldr (filterFB c p) n xs)-    = {inline} foldr (filterFB (:) p) [] xs-    = {RULE}   filter p xs--We are in an infinite loop.--A more elaborate example (that I actually saw in practice when I went to-mark GHC.List.filter as INLINABLE) is as follows. Say I have this module:-  {-# LANGUAGE RankNTypes #-}-  module GHCList where--  import Prelude hiding (filter)-  import GHC.Base (build)--  {-# INLINABLE filter #-}-  filter :: (a -> Bool) -> [a] -> [a]-  filter p [] = []-  filter p (x:xs) = if p x then x : filter p xs else filter p xs--  {-# NOINLINE [0] filterFB #-}-  filterFB :: (a -> b -> b) -> (a -> Bool) -> a -> b -> b-  filterFB c p x r | p x       = x `c` r-                   | otherwise = r--  {-# RULES-  "filter"     [~1] forall p xs.  filter p xs = build (\c n -> foldr-  (filterFB c p) n xs)-  "filterList" [1]  forall p.     foldr (filterFB (:) p) [] = filter p-   #-}--Then (because RULES are applied inside INLINABLE unfoldings, but inlinings-are not), the unfolding given to "filter" in the interface file will be:-  filter p []     = []-  filter p (x:xs) = if p x then x : build (\c n -> foldr (filterFB c p) n xs)-                           else     build (\c n -> foldr (filterFB c p) n xs--Note that because this unfolding does not mention "filter", filter is not-marked as a strong loop breaker. Therefore at a use site in another module:-  filter p xs-    = {inline}-      case xs of []     -> []-                 (x:xs) -> if p x then x : build (\c n -> foldr (filterFB c p) n xs)-                                  else     build (\c n -> foldr (filterFB c p) n xs)--  build (\c n -> foldr (filterFB c p) n xs)-    = {inline} foldr (filterFB (:) p) [] xs-    = {RULE}   filter p xs--And we are in an infinite loop again, except that this time the loop is producing an-infinitely large *term* (an unrolling of filter) and so the simplifier finally-dies with "ticks exhausted"--Because of this problem, we make a small change in the occurrence analyser-designed to mark functions like "filter" as strong loop breakers on the basis that:-  1. The RHS of filter mentions the local function "filterFB"-  2. We have a rule which mentions "filterFB" on the LHS and "filter" on the RHS--So for each RULE for an *imported* function we are going to add-dependency edges between the *local* FVS of the rule LHS and the-*local* FVS of the rule RHS. We don't do anything special for RULES on-local functions because the standard occurrence analysis stuff is-pretty good at getting loop-breakerness correct there.--It is important to note that even with this extra hack we aren't always going to get-things right. For example, it might be that the rule LHS mentions an imported Id,-and another module has a RULE that can rewrite that imported Id to one of our local-Ids.--Note [Specialising imported functions] (referred to from Specialise)-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-BUT for *automatically-generated* rules, the programmer can't be-responsible for the "programmer error" in Note [Rules for imported-functions].  In particular, consider specialising a recursive function-defined in another module.  If we specialise a recursive function B.g,-we get-         g_spec = .....(B.g Int).....-         RULE B.g Int = g_spec-Here, g_spec doesn't look recursive, but when the rule fires, it-becomes so.  And if B.g was mutually recursive, the loop might-not be as obvious as it is here.--To avoid this,- * When specialising a function that is a loop breaker,-   give a NOINLINE pragma to the specialised function--Note [Glomming]-~~~~~~~~~~~~~~~-RULES for imported Ids can make something at the top refer to something at the bottom:-        f = \x -> B.g (q x)-        h = \y -> 3--        RULE:  B.g (q x) = h x--Applying this rule makes f refer to h, although f doesn't appear to-depend on h.  (And, as in Note [Rules for imported functions], the-dependency might be more indirect. For example, f might mention C.t-rather than B.g, where C.t eventually inlines to B.g.)--NOTICE that this cannot happen for rules whose head is a-locally-defined function, because we accurately track dependencies-through RULES.  It only happens for rules whose head is an imported-function (B.g in the example above).--Solution:-  - When simplifying, bring all top level identifiers into-    scope at the start, ignoring the Rec/NonRec structure, so-    that when 'h' pops up in f's rhs, we find it in the in-scope set-    (as the simplifier generally expects). This happens in simplTopBinds.--  - In the occurrence analyser, if there are any out-of-scope-    occurrences that pop out of the top, which will happen after-    firing the rule:      f = \x -> h x-                          h = \y -> 3-    then just glom all the bindings into a single Rec, so that-    the *next* iteration of the occurrence analyser will sort-    them all out.   This part happens in occurAnalysePgm.---------------------------------------------------------------Note [Inline rules]-~~~~~~~~~~~~~~~~~~~-None of the above stuff about RULES applies to Inline Rules,-stored in a CoreUnfolding.  The unfolding, if any, is simplified-at the same time as the regular RHS of the function (ie *not* like-Note [Rules are visible in their own rec group]), so it should be-treated *exactly* like an extra RHS.--Or, rather, when computing loop-breaker edges,-  * If f has an INLINE pragma, and it is active, we treat the-    INLINE rhs as f's rhs-  * If it's inactive, we treat f as having no rhs-  * If it has no INLINE pragma, we look at f's actual rhs---There is a danger that we'll be sub-optimal if we see this-     f = ...f...-     [INLINE f = ..no f...]-where f is recursive, but the INLINE is not. This can just about-happen with a sufficiently odd set of rules; eg--        foo :: Int -> Int-        {-# INLINE [1] foo #-}-        foo x = x+1--        bar :: Int -> Int-        {-# INLINE [1] bar #-}-        bar x = foo x + 1--        {-# RULES "foo" [~1] forall x. foo x = bar x #-}--Here the RULE makes bar recursive; but it's INLINE pragma remains-non-recursive. It's tempting to then say that 'bar' should not be-a loop breaker, but an attempt to do so goes wrong in two ways:-   a) We may get-         $df = ...$cfoo...-         $cfoo = ...$df....-         [INLINE $cfoo = ...no-$df...]-      But we want $cfoo to depend on $df explicitly so that we-      put the bindings in the right order to inline $df in $cfoo-      and perhaps break the loop altogether.  (Maybe this-   b)---Example [eftInt]-~~~~~~~~~~~~~~~-Example (from GHC.Enum):--  eftInt :: Int# -> Int# -> [Int]-  eftInt x y = ...(non-recursive)...--  {-# INLINE [0] eftIntFB #-}-  eftIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> r-  eftIntFB c n x y = ...(non-recursive)...--  {-# RULES-  "eftInt"  [~1] forall x y. eftInt x y = build (\ c n -> eftIntFB c n x y)-  "eftIntList"  [1] eftIntFB  (:) [] = eftInt-   #-}--Note [Specialisation rules]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this group, which is typical of what SpecConstr builds:--   fs a = ....f (C a)....-   f  x = ....f (C a)....-   {-# RULE f (C a) = fs a #-}--So 'f' and 'fs' are in the same Rec group (since f refers to fs via its RULE).--But watch out!  If 'fs' is not chosen as a loop breaker, we may get an infinite loop:-  - the RULE is applied in f's RHS (see Note [Self-recursive rules] in GHC.Core.Op.Simplify-  - fs is inlined (say it's small)-  - now there's another opportunity to apply the RULE--This showed up when compiling Control.Concurrent.Chan.getChanContents.---------------------------------------------------------------Note [Finding join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~-It's the occurrence analyser's job to find bindings that we can turn into join-points, but it doesn't perform that transformation right away. Rather, it marks-the eligible bindings as part of their occurrence data, leaving it to the-simplifier (or to simpleOptPgm) to actually change the binder's 'IdDetails'.-The simplifier then eta-expands the RHS if needed and then updates the-occurrence sites. Dividing the work this way means that the occurrence analyser-still only takes one pass, yet one can always tell the difference between a-function call and a jump by looking at the occurrence (because the same pass-changes the 'IdDetails' and propagates the binders to their occurrence sites).--To track potential join points, we use the 'occ_tail' field of OccInfo. A value-of `AlwaysTailCalled n` indicates that every occurrence of the variable is a-tail call with `n` arguments (counting both value and type arguments). Otherwise-'occ_tail' will be 'NoTailCallInfo'. The tail call info flows bottom-up with the-rest of 'OccInfo' until it goes on the binder.--Note [Rules and join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~--Things get fiddly with rules. Suppose we have:--  let j :: Int -> Int-      j y = 2 * y-      k :: Int -> Int -> Int-      {-# RULES "SPEC k 0" k 0 = j #-}-      k x y = x + 2 * y-  in ...--Now suppose that both j and k appear only as saturated tail calls in the body.-Thus we would like to make them both join points. The rule complicates matters,-though, as its RHS has an unapplied occurrence of j. *However*, if we were to-eta-expand the rule, all would be well:--  {-# RULES "SPEC k 0" forall a. k 0 a = j a #-}--So conceivably we could notice that a potential join point would have an-"undersaturated" rule and account for it. This would mean we could make-something that's been specialised a join point, for instance. But local bindings-are rarely specialised, and being overly cautious about rules only-costs us anything when, for some `j`:--  * Before specialisation, `j` has non-tail calls, so it can't be a join point.-  * During specialisation, `j` gets specialised and thus acquires rules.-  * Sometime afterward, the non-tail calls to `j` disappear (as dead code, say),-    and so now `j` *could* become a join point.--This appears to be very rare in practice. TODO Perhaps we should gather-statistics to be sure.---------------------------------------------------------------Note [Adjusting right-hand sides]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-There's a bit of a dance we need to do after analysing a lambda expression or-a right-hand side. In particular, we need to--  a) call 'markAllInsideLam' *unless* the binding is for a thunk, a one-shot-     lambda, or a non-recursive join point; and-  b) call 'markAllNonTailCalled' *unless* the binding is for a join point.--Some examples, with how the free occurrences in e (assumed not to be a value-lambda) get marked:--                             inside lam    non-tail-called-  -------------------------------------------------------------  let x = e                  No            Yes-  let f = \x -> e            Yes           Yes-  let f = \x{OneShot} -> e   No            Yes-  \x -> e                    Yes           Yes-  join j x = e               No            No-  joinrec j x = e            Yes           No--There are a few other caveats; most importantly, if we're marking a binding as-'AlwaysTailCalled', it's *going* to be a join point, so we treat it as one so-that the effect cascades properly. Consequently, at the time the RHS is-analysed, we won't know what adjustments to make; thus 'occAnalLamOrRhs' must-return the unadjusted 'UsageDetails', to be adjusted by 'adjustRhsUsage' once-join-point-hood has been decided.--Thus the overall sequence taking place in 'occAnalNonRecBind' and-'occAnalRecBind' is as follows:--  1. Call 'occAnalLamOrRhs' to find usage information for the RHS.-  2. Call 'tagNonRecBinder' or 'tagRecBinders', which decides whether to make-     the binding a join point.-  3. Call 'adjustRhsUsage' accordingly. (Done as part of 'tagRecBinders' when-     recursive.)--(In the recursive case, this logic is spread between 'makeNode' and-'occAnalRec'.)--}-----------------------------------------------------------------------                 occAnalBind---------------------------------------------------------------------occAnalBind :: OccEnv           -- The incoming OccEnv-            -> TopLevelFlag-            -> ImpRuleEdges-            -> CoreBind-            -> UsageDetails             -- Usage details of scope-            -> (UsageDetails,           -- Of the whole let(rec)-                [CoreBind])--occAnalBind env lvl top_env (NonRec binder rhs) body_usage-  = occAnalNonRecBind env lvl top_env binder rhs body_usage-occAnalBind env lvl top_env (Rec pairs) body_usage-  = occAnalRecBind env lvl top_env pairs body_usage--------------------occAnalNonRecBind :: OccEnv -> TopLevelFlag -> ImpRuleEdges -> Var -> CoreExpr-                  -> UsageDetails -> (UsageDetails, [CoreBind])-occAnalNonRecBind env lvl imp_rule_edges binder rhs body_usage-  | isTyVar binder      -- A type let; we don't gather usage info-  = (body_usage, [NonRec binder rhs])--  | not (binder `usedIn` body_usage)    -- It's not mentioned-  = (body_usage, [])--  | otherwise                   -- It's mentioned in the body-  = (body_usage' `andUDs` rhs_usage', [NonRec tagged_binder rhs'])-  where-    (body_usage', tagged_binder) = tagNonRecBinder lvl body_usage binder-    mb_join_arity = willBeJoinId_maybe tagged_binder--    (bndrs, body) = collectBinders rhs--    (rhs_usage1, bndrs', body') = occAnalNonRecRhs env tagged_binder bndrs body-    rhs' = mkLams (markJoinOneShots mb_join_arity bndrs') body'-           -- For a /non-recursive/ join point we can mark all-           -- its join-lambda as one-shot; and it's a good idea to do so--    -- Unfoldings-    -- See Note [Unfoldings and join points]-    rhs_usage2 = case occAnalUnfolding env NonRecursive binder of-                   Just unf_usage -> rhs_usage1 `andUDs` unf_usage-                   Nothing        -> rhs_usage1--    -- Rules-    -- See Note [Rules are extra RHSs] and Note [Rule dependency info]-    rules_w_uds = occAnalRules env mb_join_arity NonRecursive tagged_binder-    rule_uds    = map (\(_, l, r) -> l `andUDs` r) rules_w_uds-    rhs_usage3 = foldr andUDs rhs_usage2 rule_uds-    rhs_usage4 = case lookupVarEnv imp_rule_edges binder of-                   Nothing -> rhs_usage3-                   Just vs -> addManyOccsSet rhs_usage3 vs-       -- See Note [Preventing loops due to imported functions rules]--    -- Final adjustment-    rhs_usage' = adjustRhsUsage mb_join_arity NonRecursive bndrs' rhs_usage4--------------------occAnalRecBind :: OccEnv -> TopLevelFlag -> ImpRuleEdges -> [(Var,CoreExpr)]-               -> UsageDetails -> (UsageDetails, [CoreBind])-occAnalRecBind env lvl imp_rule_edges pairs body_usage-  = foldr (occAnalRec env lvl) (body_usage, []) sccs-        -- For a recursive group, we-        --      * occ-analyse all the RHSs-        --      * compute strongly-connected components-        --      * feed those components to occAnalRec-        -- See Note [Recursive bindings: the grand plan]-  where-    sccs :: [SCC Details]-    sccs = {-# SCC "occAnalBind.scc" #-}-           stronglyConnCompFromEdgedVerticesUniq nodes--    nodes :: [LetrecNode]-    nodes = {-# SCC "occAnalBind.assoc" #-}-            map (makeNode env imp_rule_edges bndr_set) pairs--    bndr_set = mkVarSet (map fst pairs)--{--Note [Unfoldings and join points]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--We assume that anything in an unfolding occurs multiple times, since unfoldings-are often copied (that's the whole point!). But we still need to track tail-calls for the purpose of finding join points.--}--------------------------------occAnalRec :: OccEnv -> TopLevelFlag-           -> SCC Details-           -> (UsageDetails, [CoreBind])-           -> (UsageDetails, [CoreBind])--        -- The NonRec case is just like a Let (NonRec ...) above-occAnalRec _ lvl (AcyclicSCC (ND { nd_bndr = bndr, nd_rhs = rhs-                                 , nd_uds = rhs_uds, nd_rhs_bndrs = rhs_bndrs }))-           (body_uds, binds)-  | not (bndr `usedIn` body_uds)-  = (body_uds, binds)           -- See Note [Dead code]--  | otherwise                   -- It's mentioned in the body-  = (body_uds' `andUDs` rhs_uds',-     NonRec tagged_bndr rhs : binds)-  where-    (body_uds', tagged_bndr) = tagNonRecBinder lvl body_uds bndr-    rhs_uds' = adjustRhsUsage (willBeJoinId_maybe tagged_bndr) NonRecursive-                              rhs_bndrs rhs_uds--        -- The Rec case is the interesting one-        -- See Note [Recursive bindings: the grand plan]-        -- See Note [Loop breaking]-occAnalRec env lvl (CyclicSCC details_s) (body_uds, binds)-  | not (any (`usedIn` body_uds) bndrs) -- NB: look at body_uds, not total_uds-  = (body_uds, binds)                   -- See Note [Dead code]--  | otherwise   -- At this point we always build a single Rec-  = -- pprTrace "occAnalRec" (vcat-    --  [ text "weak_fvs" <+> ppr weak_fvs-    --  , text "lb nodes" <+> ppr loop_breaker_nodes])-    (final_uds, Rec pairs : binds)--  where-    bndrs    = map nd_bndr details_s-    bndr_set = mkVarSet bndrs--    -------------------------------        -- See Note [Choosing loop breakers] for loop_breaker_nodes-    final_uds :: UsageDetails-    loop_breaker_nodes :: [LetrecNode]-    (final_uds, loop_breaker_nodes)-      = mkLoopBreakerNodes env lvl bndr_set body_uds details_s--    -------------------------------    weak_fvs :: VarSet-    weak_fvs = mapUnionVarSet nd_weak details_s--    ----------------------------    -- Now reconstruct the cycle-    pairs :: [(Id,CoreExpr)]-    pairs | isEmptyVarSet weak_fvs = reOrderNodes   0 bndr_set weak_fvs loop_breaker_nodes []-          | otherwise              = loopBreakNodes 0 bndr_set weak_fvs loop_breaker_nodes []-          -- If weak_fvs is empty, the loop_breaker_nodes will include-          -- all the edges in the original scope edges [remember,-          -- weak_fvs is the difference between scope edges and-          -- lb-edges], so a fresh SCC computation would yield a-          -- single CyclicSCC result; and reOrderNodes deals with-          -- exactly that case------------------------------------------------------------------------                 Loop breaking---------------------------------------------------------------------type Binding = (Id,CoreExpr)--loopBreakNodes :: Int-               -> VarSet        -- All binders-               -> VarSet        -- Binders whose dependencies may be "missing"-                                -- See Note [Weak loop breakers]-               -> [LetrecNode]-               -> [Binding]             -- Append these to the end-               -> [Binding]-{--loopBreakNodes is applied to the list of nodes for a cyclic strongly-connected component (there's guaranteed to be a cycle).  It returns-the same nodes, but-        a) in a better order,-        b) with some of the Ids having a IAmALoopBreaker pragma--The "loop-breaker" Ids are sufficient to break all cycles in the SCC.  This means-that the simplifier can guarantee not to loop provided it never records an inlining-for these no-inline guys.--Furthermore, the order of the binds is such that if we neglect dependencies-on the no-inline Ids then the binds are topologically sorted.  This means-that the simplifier will generally do a good job if it works from top bottom,-recording inlinings for any Ids which aren't marked as "no-inline" as it goes.--}---- Return the bindings sorted into a plausible order, and marked with loop breakers.-loopBreakNodes depth bndr_set weak_fvs nodes binds-  = -- pprTrace "loopBreakNodes" (ppr nodes) $-    go (stronglyConnCompFromEdgedVerticesUniqR nodes) binds-  where-    go []         binds = binds-    go (scc:sccs) binds = loop_break_scc scc (go sccs binds)--    loop_break_scc scc binds-      = case scc of-          AcyclicSCC node  -> mk_non_loop_breaker weak_fvs node : binds-          CyclicSCC nodes  -> reOrderNodes depth bndr_set weak_fvs nodes binds-------------------------------------reOrderNodes :: Int -> VarSet -> VarSet -> [LetrecNode] -> [Binding] -> [Binding]-    -- Choose a loop breaker, mark it no-inline,-    -- and call loopBreakNodes on the rest-reOrderNodes _ _ _ []     _     = panic "reOrderNodes"-reOrderNodes _ _ _ [node] binds = mk_loop_breaker node : binds-reOrderNodes depth bndr_set weak_fvs (node : nodes) binds-  = -- pprTrace "reOrderNodes" (vcat [ text "unchosen" <+> ppr unchosen-    --                              , text "chosen" <+> ppr chosen_nodes ]) $-    loopBreakNodes new_depth bndr_set weak_fvs unchosen $-    (map mk_loop_breaker chosen_nodes ++ binds)-  where-    (chosen_nodes, unchosen) = chooseLoopBreaker approximate_lb-                                                 (nd_score (node_payload node))-                                                 [node] [] nodes--    approximate_lb = depth >= 2-    new_depth | approximate_lb = 0-              | otherwise      = depth+1-        -- After two iterations (d=0, d=1) give up-        -- and approximate, returning to d=0--mk_loop_breaker :: LetrecNode -> Binding-mk_loop_breaker (node_payload -> ND { nd_bndr = bndr, nd_rhs = rhs})-  = (bndr `setIdOccInfo` strongLoopBreaker { occ_tail = tail_info }, rhs)-  where-    tail_info = tailCallInfo (idOccInfo bndr)--mk_non_loop_breaker :: VarSet -> LetrecNode -> Binding--- See Note [Weak loop breakers]-mk_non_loop_breaker weak_fvs (node_payload -> ND { nd_bndr = bndr-                                                 , nd_rhs = rhs})-  | bndr `elemVarSet` weak_fvs = (setIdOccInfo bndr occ', rhs)-  | otherwise                  = (bndr, rhs)-  where-    occ' = weakLoopBreaker { occ_tail = tail_info }-    tail_info = tailCallInfo (idOccInfo bndr)-------------------------------------chooseLoopBreaker :: Bool             -- True <=> Too many iterations,-                                      --          so approximate-                  -> NodeScore            -- Best score so far-                  -> [LetrecNode]       -- Nodes with this score-                  -> [LetrecNode]       -- Nodes with higher scores-                  -> [LetrecNode]       -- Unprocessed nodes-                  -> ([LetrecNode], [LetrecNode])-    -- This loop looks for the bind with the lowest score-    -- to pick as the loop  breaker.  The rest accumulate in-chooseLoopBreaker _ _ loop_nodes acc []-  = (loop_nodes, acc)        -- Done--    -- If approximate_loop_breaker is True, we pick *all*-    -- nodes with lowest score, else just one-    -- See Note [Complexity of loop breaking]-chooseLoopBreaker approx_lb loop_sc loop_nodes acc (node : nodes)-  | approx_lb-  , rank sc == rank loop_sc-  = chooseLoopBreaker approx_lb loop_sc (node : loop_nodes) acc nodes--  | sc `betterLB` loop_sc  -- Better score so pick this new one-  = chooseLoopBreaker approx_lb sc [node] (loop_nodes ++ acc) nodes--  | otherwise              -- Worse score so don't pick it-  = chooseLoopBreaker approx_lb loop_sc loop_nodes (node : acc) nodes-  where-    sc = nd_score (node_payload node)--{--Note [Complexity of loop breaking]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The loop-breaking algorithm knocks out one binder at a time, and-performs a new SCC analysis on the remaining binders.  That can-behave very badly in tightly-coupled groups of bindings; in the-worst case it can be (N**2)*log N, because it does a full SCC-on N, then N-1, then N-2 and so on.--To avoid this, we switch plans after 2 (or whatever) attempts:-  Plan A: pick one binder with the lowest score, make it-          a loop breaker, and try again-  Plan B: pick *all* binders with the lowest score, make them-          all loop breakers, and try again-Since there are only a small finite number of scores, this will-terminate in a constant number of iterations, rather than O(N)-iterations.--You might thing that it's very unlikely, but RULES make it much-more likely.  Here's a real example from #1969:-  Rec { $dm = \d.\x. op d-        {-# RULES forall d. $dm Int d  = $s$dm1-                  forall d. $dm Bool d = $s$dm2 #-}--        dInt = MkD .... opInt ...-        dInt = MkD .... opBool ...-        opInt  = $dm dInt-        opBool = $dm dBool--        $s$dm1 = \x. op dInt-        $s$dm2 = \x. op dBool }-The RULES stuff means that we can't choose $dm as a loop breaker-(Note [Choosing loop breakers]), so we must choose at least (say)-opInt *and* opBool, and so on.  The number of loop breakders is-linear in the number of instance declarations.--Note [Loop breakers and INLINE/INLINABLE pragmas]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Avoid choosing a function with an INLINE pramga as the loop breaker!-If such a function is mutually-recursive with a non-INLINE thing,-then the latter should be the loop-breaker.--It's vital to distinguish between INLINE and INLINABLE (the-Bool returned by hasStableCoreUnfolding_maybe).  If we start with-   Rec { {-# INLINABLE f #-}-         f x = ...f... }-and then worker/wrapper it through strictness analysis, we'll get-   Rec { {-# INLINABLE $wf #-}-         $wf p q = let x = (p,q) in ...f...--         {-# INLINE f #-}-         f x = case x of (p,q) -> $wf p q }--Now it is vital that we choose $wf as the loop breaker, so we can-inline 'f' in '$wf'.--Note [DFuns should not be loop breakers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's particularly bad to make a DFun into a loop breaker.  See-Note [How instance declarations are translated] in TcInstDcls--We give DFuns a higher score than ordinary CONLIKE things because-if there's a choice we want the DFun to be the non-loop breaker. Eg--rec { sc = /\ a \$dC. $fBWrap (T a) ($fCT @ a $dC)--      $fCT :: forall a_afE. (Roman.C a_afE) => Roman.C (Roman.T a_afE)-      {-# DFUN #-}-      $fCT = /\a \$dC. MkD (T a) ((sc @ a $dC) |> blah) ($ctoF @ a $dC)-    }--Here 'sc' (the superclass) looks CONLIKE, but we'll never get to it-if we can't unravel the DFun first.--Note [Constructor applications]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's really really important to inline dictionaries.  Real-example (the Enum Ordering instance from GHC.Base):--     rec     f = \ x -> case d of (p,q,r) -> p x-             g = \ x -> case d of (p,q,r) -> q x-             d = (v, f, g)--Here, f and g occur just once; but we can't inline them into d.-On the other hand we *could* simplify those case expressions if-we didn't stupidly choose d as the loop breaker.-But we won't because constructor args are marked "Many".-Inlining dictionaries is really essential to unravelling-the loops in static numeric dictionaries, see GHC.Float.--Note [Closure conversion]-~~~~~~~~~~~~~~~~~~~~~~~~~-We treat (\x. C p q) as a high-score candidate in the letrec scoring algorithm.-The immediate motivation came from the result of a closure-conversion transformation-which generated code like this:--    data Clo a b = forall c. Clo (c -> a -> b) c--    ($:) :: Clo a b -> a -> b-    Clo f env $: x = f env x--    rec { plus = Clo plus1 ()--        ; plus1 _ n = Clo plus2 n--        ; plus2 Zero     n = n-        ; plus2 (Succ m) n = Succ (plus $: m $: n) }--If we inline 'plus' and 'plus1', everything unravels nicely.  But if-we choose 'plus1' as the loop breaker (which is entirely possible-otherwise), the loop does not unravel nicely.---@occAnalUnfolding@ deals with the question of bindings where the Id is marked-by an INLINE pragma.  For these we record that anything which occurs-in its RHS occurs many times.  This pessimistically assumes that this-inlined binder also occurs many times in its scope, but if it doesn't-we'll catch it next time round.  At worst this costs an extra simplifier pass.-ToDo: try using the occurrence info for the inline'd binder.--[March 97] We do the same for atomic RHSs.  Reason: see notes with loopBreakSCC.-[June 98, SLPJ]  I've undone this change; I don't understand it.  See notes with loopBreakSCC.---************************************************************************-*                                                                      *-                   Making nodes-*                                                                      *-************************************************************************--}--type ImpRuleEdges = IdEnv IdSet     -- Mapping from FVs of imported RULE LHSs to RHS FVs--noImpRuleEdges :: ImpRuleEdges-noImpRuleEdges = emptyVarEnv--type LetrecNode = Node Unique Details  -- Node comes from Digraph-                                       -- The Unique key is gotten from the Id-data Details-  = ND { nd_bndr :: Id          -- Binder-       , nd_rhs  :: CoreExpr    -- RHS, already occ-analysed-       , nd_rhs_bndrs :: [CoreBndr] -- Outer lambdas of RHS-                                    -- INVARIANT: (nd_rhs_bndrs nd, _) ==-                                    --              collectBinders (nd_rhs nd)--       , nd_uds  :: UsageDetails  -- Usage from RHS, and RULES, and stable unfoldings-                                  -- ignoring phase (ie assuming all are active)-                                  -- See Note [Forming Rec groups]--       , nd_inl  :: IdSet       -- Free variables of-                                --   the stable unfolding (if present and active)-                                --   or the RHS (if not)-                                -- but excluding any RULES-                                -- This is the IdSet that may be used if the Id is inlined--       , nd_weak :: IdSet       -- Binders of this Rec that are mentioned in nd_uds-                                -- but are *not* in nd_inl.  These are the ones whose-                                -- dependencies might not be respected by loop_breaker_nodes-                                -- See Note [Weak loop breakers]--       , nd_active_rule_fvs :: IdSet   -- Free variables of the RHS of active RULES--       , nd_score :: NodeScore-  }--instance Outputable Details where-   ppr nd = text "ND" <> braces-             (sep [ text "bndr =" <+> ppr (nd_bndr nd)-                  , text "uds =" <+> ppr (nd_uds nd)-                  , text "inl =" <+> ppr (nd_inl nd)-                  , text "weak =" <+> ppr (nd_weak nd)-                  , text "rule =" <+> ppr (nd_active_rule_fvs nd)-                  , text "score =" <+> ppr (nd_score nd)-             ])---- The NodeScore is compared lexicographically;---      e.g. lower rank wins regardless of size-type NodeScore = ( Int     -- Rank: lower => more likely to be picked as loop breaker-                 , Int     -- Size of rhs: higher => more likely to be picked as LB-                           -- Maxes out at maxExprSize; we just use it to prioritise-                           -- small functions-                 , Bool )  -- Was it a loop breaker before?-                           -- True => more likely to be picked-                           -- Note [Loop breakers, node scoring, and stability]--rank :: NodeScore -> Int-rank (r, _, _) = r--makeNode :: OccEnv -> ImpRuleEdges -> VarSet-         -> (Var, CoreExpr) -> LetrecNode--- See Note [Recursive bindings: the grand plan]-makeNode env imp_rule_edges bndr_set (bndr, rhs)-  = DigraphNode details (varUnique bndr) (nonDetKeysUniqSet node_fvs)-    -- It's OK to use nonDetKeysUniqSet here as stronglyConnCompFromEdgedVerticesR-    -- is still deterministic with edges in nondeterministic order as-    -- explained in Note [Deterministic SCC] in Digraph.-  where-    details = ND { nd_bndr            = bndr-                 , nd_rhs             = rhs'-                 , nd_rhs_bndrs       = bndrs'-                 , nd_uds             = rhs_usage3-                 , nd_inl             = inl_fvs-                 , nd_weak            = node_fvs `minusVarSet` inl_fvs-                 , nd_active_rule_fvs = active_rule_fvs-                 , nd_score           = pprPanic "makeNodeDetails" (ppr bndr) }--    -- Constructing the edges for the main Rec computation-    -- See Note [Forming Rec groups]-    (bndrs, body) = collectBinders rhs-    (rhs_usage1, bndrs', body') = occAnalRecRhs env bndrs body-    rhs' = mkLams bndrs' body'-    rhs_usage2 = foldr andUDs rhs_usage1 rule_uds-                   -- Note [Rules are extra RHSs]-                   -- Note [Rule dependency info]-    rhs_usage3 = case mb_unf_uds of-                   Just unf_uds -> rhs_usage2 `andUDs` unf_uds-                   Nothing      -> rhs_usage2-    node_fvs = udFreeVars bndr_set rhs_usage3--    -- Finding the free variables of the rules-    is_active = occ_rule_act env :: Activation -> Bool--    rules_w_uds :: [(CoreRule, UsageDetails, UsageDetails)]-    rules_w_uds = occAnalRules env (Just (length bndrs)) Recursive bndr--    rules_w_rhs_fvs :: [(Activation, VarSet)]    -- Find the RHS fvs-    rules_w_rhs_fvs = maybe id (\ids -> ((AlwaysActive, ids):))-                               (lookupVarEnv imp_rule_edges bndr)-      -- See Note [Preventing loops due to imported functions rules]-                      [ (ru_act rule, udFreeVars bndr_set rhs_uds)-                      | (rule, _, rhs_uds) <- rules_w_uds ]-    rule_uds = map (\(_, l, r) -> l `andUDs` r) rules_w_uds-    active_rule_fvs = unionVarSets [fvs | (a,fvs) <- rules_w_rhs_fvs-                                        , is_active a]--    -- Finding the usage details of the INLINE pragma (if any)-    mb_unf_uds = occAnalUnfolding env Recursive bndr--    -- Find the "nd_inl" free vars; for the loop-breaker phase-    inl_fvs = case mb_unf_uds of-                Nothing -> udFreeVars bndr_set rhs_usage1 -- No INLINE, use RHS-                Just unf_uds -> udFreeVars bndr_set unf_uds-                      -- We could check for an *active* INLINE (returning-                      -- emptyVarSet for an inactive one), but is_active-                      -- isn't the right thing (it tells about-                      -- RULE activation), so we'd need more plumbing--mkLoopBreakerNodes :: OccEnv -> TopLevelFlag-                   -> VarSet-                   -> UsageDetails   -- for BODY of let-                   -> [Details]-                   -> (UsageDetails, -- adjusted-                       [LetrecNode])--- Does four things---   a) tag each binder with its occurrence info---   b) add a NodeScore to each node---   c) make a Node with the right dependency edges for---      the loop-breaker SCC analysis---   d) adjust each RHS's usage details according to---      the binder's (new) shotness and join-point-hood-mkLoopBreakerNodes env lvl bndr_set body_uds details_s-  = (final_uds, zipWith mk_lb_node details_s bndrs')-  where-    (final_uds, bndrs') = tagRecBinders lvl body_uds-                            [ ((nd_bndr nd)-                               ,(nd_uds nd)-                               ,(nd_rhs_bndrs nd))-                            | nd <- details_s ]-    mk_lb_node nd@(ND { nd_bndr = bndr, nd_rhs = rhs, nd_inl = inl_fvs }) bndr'-      = DigraphNode nd' (varUnique bndr) (nonDetKeysUniqSet lb_deps)-              -- It's OK to use nonDetKeysUniqSet here as-              -- stronglyConnCompFromEdgedVerticesR is still deterministic with edges-              -- in nondeterministic order as explained in-              -- Note [Deterministic SCC] in Digraph.-      where-        nd'     = nd { nd_bndr = bndr', nd_score = score }-        score   = nodeScore env bndr bndr' rhs lb_deps-        lb_deps = extendFvs_ rule_fv_env inl_fvs--    rule_fv_env :: IdEnv IdSet-        -- Maps a variable f to the variables from this group-        --      mentioned in RHS of active rules for f-        -- Domain is *subset* of bound vars (others have no rule fvs)-    rule_fv_env = transClosureFV (mkVarEnv init_rule_fvs)-    init_rule_fvs   -- See Note [Finding rule RHS free vars]-      = [ (b, trimmed_rule_fvs)-        | ND { nd_bndr = b, nd_active_rule_fvs = rule_fvs } <- details_s-        , let trimmed_rule_fvs = rule_fvs `intersectVarSet` bndr_set-        , not (isEmptyVarSet trimmed_rule_fvs) ]----------------------------------------------nodeScore :: OccEnv-          -> Id        -- Binder has old occ-info (just for loop-breaker-ness)-          -> Id        -- Binder with new occ-info-          -> CoreExpr  -- RHS-          -> VarSet    -- Loop-breaker dependencies-          -> NodeScore-nodeScore env old_bndr new_bndr bind_rhs lb_deps-  | not (isId old_bndr)     -- A type or coercion variable is never a loop breaker-  = (100, 0, False)--  | old_bndr `elemVarSet` lb_deps  -- Self-recursive things are great loop breakers-  = (0, 0, True)                   -- See Note [Self-recursion and loop breakers]--  | not (occ_unf_act env old_bndr) -- A binder whose inlining is inactive (e.g. has-  = (0, 0, True)                   -- a NOINLINE pragma) makes a great loop breaker--  | exprIsTrivial rhs-  = mk_score 10  -- Practically certain to be inlined-    -- Used to have also: && not (isExportedId bndr)-    -- But I found this sometimes cost an extra iteration when we have-    --      rec { d = (a,b); a = ...df...; b = ...df...; df = d }-    -- where df is the exported dictionary. Then df makes a really-    -- bad choice for loop breaker--  | DFunUnfolding { df_args = args } <- id_unfolding-    -- Never choose a DFun as a loop breaker-    -- Note [DFuns should not be loop breakers]-  = (9, length args, is_lb)--    -- Data structures are more important than INLINE pragmas-    -- so that dictionary/method recursion unravels--  | CoreUnfolding { uf_guidance = UnfWhen {} } <- id_unfolding-  = mk_score 6--  | is_con_app rhs   -- Data types help with cases:-  = mk_score 5       -- Note [Constructor applications]--  | isStableUnfolding id_unfolding-  , can_unfold-  = mk_score 3--  | isOneOcc (idOccInfo new_bndr)-  = mk_score 2  -- Likely to be inlined--  | can_unfold  -- The Id has some kind of unfolding-  = mk_score 1--  | otherwise-  = (0, 0, is_lb)--  where-    mk_score :: Int -> NodeScore-    mk_score rank = (rank, rhs_size, is_lb)--    is_lb    = isStrongLoopBreaker (idOccInfo old_bndr)-    rhs      = case id_unfolding of-                 CoreUnfolding { uf_src = src, uf_tmpl = unf_rhs }-                    | isStableSource src-                    -> unf_rhs-                 _  -> bind_rhs-       -- 'bind_rhs' is irrelevant for inlining things with a stable unfolding-    rhs_size = case id_unfolding of-                 CoreUnfolding { uf_guidance = guidance }-                    | UnfIfGoodArgs { ug_size = size } <- guidance-                    -> size-                 _  -> cheapExprSize rhs--    can_unfold   = canUnfold id_unfolding-    id_unfolding = realIdUnfolding old_bndr-       -- realIdUnfolding: Ignore loop-breaker-ness here because-       -- that is what we are setting!--        -- Checking for a constructor application-        -- Cheap and cheerful; the simplifier moves casts out of the way-        -- The lambda case is important to spot x = /\a. C (f a)-        -- which comes up when C is a dictionary constructor and-        -- f is a default method.-        -- Example: the instance for Show (ST s a) in GHC.ST-        ---        -- However we *also* treat (\x. C p q) as a con-app-like thing,-        --      Note [Closure conversion]-    is_con_app (Var v)    = isConLikeId v-    is_con_app (App f _)  = is_con_app f-    is_con_app (Lam _ e)  = is_con_app e-    is_con_app (Tick _ e) = is_con_app e-    is_con_app _          = False--maxExprSize :: Int-maxExprSize = 20  -- Rather arbitrary--cheapExprSize :: CoreExpr -> Int--- Maxes out at maxExprSize-cheapExprSize e-  = go 0 e-  where-    go n e | n >= maxExprSize = n-           | otherwise        = go1 n e--    go1 n (Var {})        = n+1-    go1 n (Lit {})        = n+1-    go1 n (Type {})       = n-    go1 n (Coercion {})   = n-    go1 n (Tick _ e)      = go1 n e-    go1 n (Cast e _)      = go1 n e-    go1 n (App f a)       = go (go1 n f) a-    go1 n (Lam b e)-      | isTyVar b         = go1 n e-      | otherwise         = go (n+1) e-    go1 n (Let b e)       = gos (go1 n e) (rhssOfBind b)-    go1 n (Case e _ _ as) = gos (go1 n e) (rhssOfAlts as)--    gos n [] = n-    gos n (e:es) | n >= maxExprSize = n-                 | otherwise        = gos (go1 n e) es--betterLB :: NodeScore -> NodeScore -> Bool--- If  n1 `betterLB` n2  then choose n1 as the loop breaker-betterLB (rank1, size1, lb1) (rank2, size2, _)-  | rank1 < rank2 = True-  | rank1 > rank2 = False-  | size1 < size2 = False   -- Make the bigger n2 into the loop breaker-  | size1 > size2 = True-  | lb1           = True    -- Tie-break: if n1 was a loop breaker before, choose it-  | otherwise     = False   -- See Note [Loop breakers, node scoring, and stability]--{- Note [Self-recursion and loop breakers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If we have-   rec { f = ...f...g...-       ; g = .....f...   }-then 'f' has to be a loop breaker anyway, so we may as well choose it-right away, so that g can inline freely.--This is really just a cheap hack. Consider-   rec { f = ...g...-       ; g = ..f..h...-      ;  h = ...f....}-Here f or g are better loop breakers than h; but we might accidentally-choose h.  Finding the minimal set of loop breakers is hard.--Note [Loop breakers, node scoring, and stability]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-To choose a loop breaker, we give a NodeScore to each node in the SCC,-and pick the one with the best score (according to 'betterLB').--We need to be jolly careful (#12425, #12234) about the stability-of this choice. Suppose we have--    let rec { f = ...g...g...-            ; g = ...f...f... }-    in-    case x of-      True  -> ...f..-      False -> ..f...--In each iteration of the simplifier the occurrence analyser OccAnal-chooses a loop breaker. Suppose in iteration 1 it choose g as the loop-breaker. That means it is free to inline f.--Suppose that GHC decides to inline f in the branches of the case, but-(for some reason; eg it is not saturated) in the rhs of g. So we get--    let rec { f = ...g...g...-            ; g = ...f...f... }-    in-    case x of-      True  -> ...g...g.....-      False -> ..g..g....--Now suppose that, for some reason, in the next iteration the occurrence-analyser chooses f as the loop breaker, so it can freely inline g. And-again for some reason the simplifier inlines g at its calls in the case-branches, but not in the RHS of f. Then we get--    let rec { f = ...g...g...-            ; g = ...f...f... }-    in-    case x of-      True  -> ...(...f...f...)...(...f..f..).....-      False -> ..(...f...f...)...(..f..f...)....--You can see where this is going! Each iteration of the simplifier-doubles the number of calls to f or g. No wonder GHC is slow!--(In the particular example in comment:3 of #12425, f and g are the two-mutually recursive fmap instances for CondT and Result. They are both-marked INLINE which, oddly, is why they don't inline in each other's-RHS, because the call there is not saturated.)--The root cause is that we flip-flop on our choice of loop breaker. I-always thought it didn't matter, and indeed for any single iteration-to terminate, it doesn't matter. But when we iterate, it matters a-lot!!--So The Plan is this:-   If there is a tie, choose the node that-   was a loop breaker last time round--Hence the is_lb field of NodeScore--************************************************************************-*                                                                      *-                   Right hand sides-*                                                                      *-************************************************************************--}--occAnalRhs :: OccEnv -> RecFlag -> Id -> [CoreBndr] -> CoreExpr-           -> (UsageDetails, [CoreBndr], CoreExpr)-              -- Returned usage details covers only the RHS,-              -- and *not* the RULE or INLINE template for the Id-occAnalRhs env Recursive _ bndrs body-  = occAnalRecRhs env bndrs body-occAnalRhs env NonRecursive id bndrs body-  = occAnalNonRecRhs env id bndrs body--occAnalRecRhs :: OccEnv -> [CoreBndr] -> CoreExpr    -- Rhs lambdas, body-           -> (UsageDetails, [CoreBndr], CoreExpr)-              -- Returned usage details covers only the RHS,-              -- and *not* the RULE or INLINE template for the Id-occAnalRecRhs env bndrs body = occAnalLamOrRhs (rhsCtxt env) bndrs body--occAnalNonRecRhs :: OccEnv-                 -> Id -> [CoreBndr] -> CoreExpr    -- Binder; rhs lams, body-                     -- Binder is already tagged with occurrence info-                 -> (UsageDetails, [CoreBndr], CoreExpr)-              -- Returned usage details covers only the RHS,-              -- and *not* the RULE or INLINE template for the Id-occAnalNonRecRhs env bndr bndrs body-  = occAnalLamOrRhs rhs_env bndrs body-  where-    env1 | is_join_point    = env  -- See Note [Join point RHSs]-         | certainly_inline = env  -- See Note [Cascading inlines]-         | otherwise        = rhsCtxt env--    -- See Note [Sources of one-shot information]-    rhs_env = env1 { occ_one_shots = argOneShots dmd }--    certainly_inline -- See Note [Cascading inlines]-      = case occ of-          OneOcc { occ_in_lam = NotInsideLam, occ_one_br = InOneBranch }-            -> active && not_stable-          _ -> False--    is_join_point = isAlwaysTailCalled occ-    -- Like (isJoinId bndr) but happens one step earlier-    --  c.f. willBeJoinId_maybe--    occ        = idOccInfo bndr-    dmd        = idDemandInfo bndr-    active     = isAlwaysActive (idInlineActivation bndr)-    not_stable = not (isStableUnfolding (idUnfolding bndr))--occAnalUnfolding :: OccEnv-                 -> RecFlag-                 -> Id-                 -> Maybe UsageDetails-                      -- Just the analysis, not a new unfolding. The unfolding-                      -- got analysed when it was created and we don't need to-                      -- update it.-occAnalUnfolding env rec_flag id-  = case realIdUnfolding id of -- ignore previous loop-breaker flag-      CoreUnfolding { uf_tmpl = rhs, uf_src = src }-        | not (isStableSource src)-        -> Nothing-        | otherwise-        -> Just $ markAllMany usage-        where-          (bndrs, body) = collectBinders rhs-          (usage, _, _) = occAnalRhs env rec_flag id bndrs body--      DFunUnfolding { df_bndrs = bndrs, df_args = args }-        -> Just $ zapDetails (delDetailsList usage bndrs)-        where-          usage = andUDsList (map (fst . occAnal env) args)--      _ -> Nothing--occAnalRules :: OccEnv-             -> Maybe JoinArity -- If the binder is (or MAY become) a join-                                -- point, what its join arity is (or WOULD-                                -- become). See Note [Rules and join points].-             -> RecFlag-             -> Id-             -> [(CoreRule,      -- Each (non-built-in) rule-                  UsageDetails,  -- Usage details for LHS-                  UsageDetails)] -- Usage details for RHS-occAnalRules env mb_expected_join_arity rec_flag id-  = [ (rule, lhs_uds, rhs_uds) | rule@Rule {} <- idCoreRules id-                               , let (lhs_uds, rhs_uds) = occ_anal_rule rule ]-  where-    occ_anal_rule (Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs })-      = (lhs_uds, final_rhs_uds)-      where-        lhs_uds = addManyOccsSet emptyDetails $-                    (exprsFreeVars args `delVarSetList` bndrs)-        (rhs_bndrs, rhs_body) = collectBinders rhs-        (rhs_uds, _, _) = occAnalRhs env rec_flag id rhs_bndrs rhs_body-                            -- Note [Rules are extra RHSs]-                            -- Note [Rule dependency info]-        final_rhs_uds = adjust_tail_info args $ markAllMany $-                          (rhs_uds `delDetailsList` bndrs)-    occ_anal_rule _-      = (emptyDetails, emptyDetails)--    adjust_tail_info args uds -- see Note [Rules and join points]-      = case mb_expected_join_arity of-          Just ar | args `lengthIs` ar -> uds-          _                            -> markAllNonTailCalled uds-{- Note [Join point RHSs]-~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-   x = e-   join j = Just x--We want to inline x into j right away, so we don't want to give-the join point a RhsCtxt (#14137).  It's not a huge deal, because-the FloatIn pass knows to float into join point RHSs; and the simplifier-does not float things out of join point RHSs.  But it's a simple, cheap-thing to do.  See #14137.--Note [Cascading inlines]-~~~~~~~~~~~~~~~~~~~~~~~~-By default we use an rhsCtxt for the RHS of a binding.  This tells the-occ anal n that it's looking at an RHS, which has an effect in-occAnalApp.  In particular, for constructor applications, it makes-the arguments appear to have NoOccInfo, so that we don't inline into-them. Thus    x = f y-              k = Just x-we do not want to inline x.--But there's a problem.  Consider-     x1 = a0 : []-     x2 = a1 : x1-     x3 = a2 : x2-     g  = f x3-First time round, it looks as if x1 and x2 occur as an arg of a-let-bound constructor ==> give them a many-occurrence.-But then x3 is inlined (unconditionally as it happens) and-next time round, x2 will be, and the next time round x1 will be-Result: multiple simplifier iterations.  Sigh.--So, when analysing the RHS of x3 we notice that x3 will itself-definitely inline the next time round, and so we analyse x3's rhs in-an ordinary context, not rhsCtxt.  Hence the "certainly_inline" stuff.--Annoyingly, we have to approximate GHC.Core.Op.Simplify.Utils.preInlineUnconditionally.-If (a) the RHS is expandable (see isExpandableApp in occAnalApp), and-   (b) certainly_inline says "yes" when preInlineUnconditionally says "no"-then the simplifier iterates indefinitely:-        x = f y-        k = Just x   -- We decide that k is 'certainly_inline'-        v = ...k...  -- but preInlineUnconditionally doesn't inline it-inline ==>-        k = Just (f y)-        v = ...k...-float ==>-        x1 = f y-        k = Just x1-        v = ...k...--This is worse than the slow cascade, so we only want to say "certainly_inline"-if it really is certain.  Look at the note with preInlineUnconditionally-for the various clauses.---************************************************************************-*                                                                      *-                Expressions-*                                                                      *-************************************************************************--}--occAnal :: OccEnv-        -> CoreExpr-        -> (UsageDetails,       -- Gives info only about the "interesting" Ids-            CoreExpr)--occAnal _   expr@(Type _) = (emptyDetails,         expr)-occAnal _   expr@(Lit _)  = (emptyDetails,         expr)-occAnal env expr@(Var _)  = occAnalApp env (expr, [], [])-    -- At one stage, I gathered the idRuleVars for the variable here too,-    -- which in a way is the right thing to do.-    -- But that went wrong right after specialisation, when-    -- the *occurrences* of the overloaded function didn't have any-    -- rules in them, so the *specialised* versions looked as if they-    -- weren't used at all.--occAnal _ (Coercion co)-  = (addManyOccsSet emptyDetails (coVarsOfCo co), Coercion co)-        -- See Note [Gather occurrences of coercion variables]--{--Note [Gather occurrences of coercion variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We need to gather info about what coercion variables appear, so that-we can sort them into the right place when doing dependency analysis.--}--occAnal env (Tick tickish body)-  | SourceNote{} <- tickish-  = (usage, Tick tickish body')-                  -- SourceNotes are best-effort; so we just proceed as usual.-                  -- If we drop a tick due to the issues described below it's-                  -- not the end of the world.--  | tickish `tickishScopesLike` SoftScope-  = (markAllNonTailCalled usage, Tick tickish body')--  | Breakpoint _ ids <- tickish-  = (usage_lam `andUDs` foldr addManyOccs emptyDetails ids, Tick tickish body')-    -- never substitute for any of the Ids in a Breakpoint--  | otherwise-  = (usage_lam, Tick tickish body')-  where-    !(usage,body') = occAnal env body-    -- for a non-soft tick scope, we can inline lambdas only-    usage_lam = markAllNonTailCalled (markAllInsideLam usage)-                  -- TODO There may be ways to make ticks and join points play-                  -- nicer together, but right now there are problems:-                  --   let j x = ... in tick<t> (j 1)-                  -- Making j a join point may cause the simplifier to drop t-                  -- (if the tick is put into the continuation). So we don't-                  -- count j 1 as a tail call.-                  -- See #14242.--occAnal env (Cast expr co)-  = case occAnal env expr of { (usage, expr') ->-    let usage1 = zapDetailsIf (isRhsEnv env) usage-          -- usage1: if we see let x = y `cast` co-          -- then mark y as 'Many' so that we don't-          -- immediately inline y again.-        usage2 = addManyOccsSet usage1 (coVarsOfCo co)-          -- usage2: see Note [Gather occurrences of coercion variables]-    in (markAllNonTailCalled usage2, Cast expr' co)-    }--occAnal env app@(App _ _)-  = occAnalApp env (collectArgsTicks tickishFloatable app)---- Ignore type variables altogether---   (a) occurrences inside type lambdas only not marked as InsideLam---   (b) type variables not in environment--occAnal env (Lam x body)-  | isTyVar x-  = case occAnal env body of { (body_usage, body') ->-    (markAllNonTailCalled body_usage, Lam x body')-    }---- For value lambdas we do a special hack.  Consider---      (\x. \y. ...x...)--- If we did nothing, x is used inside the \y, so would be marked--- as dangerous to dup.  But in the common case where the abstraction--- is applied to two arguments this is over-pessimistic.--- So instead, we just mark each binder with its occurrence--- info in the *body* of the multiple lambda.--- Then, the simplifier is careful when partially applying lambdas.--occAnal env expr@(Lam _ _)-  = case occAnalLamOrRhs env binders body of { (usage, tagged_binders, body') ->-    let-        expr'       = mkLams tagged_binders body'-        usage1      = markAllNonTailCalled usage-        one_shot_gp = all isOneShotBndr tagged_binders-        final_usage | one_shot_gp = usage1-                    | otherwise   = markAllInsideLam usage1-    in-    (final_usage, expr') }-  where-    (binders, body) = collectBinders expr--occAnal env (Case scrut bndr ty alts)-  = case occ_anal_scrut scrut alts     of { (scrut_usage, scrut') ->-    case mapAndUnzip occ_anal_alt alts of { (alts_usage_s, alts')   ->-    let-        alts_usage  = foldr orUDs emptyDetails alts_usage_s-        (alts_usage1, tagged_bndr) = tagLamBinder alts_usage bndr-        total_usage = markAllNonTailCalled scrut_usage `andUDs` alts_usage1-                        -- Alts can have tail calls, but the scrutinee can't-    in-    total_usage `seq` (total_usage, Case scrut' tagged_bndr ty alts') }}-  where-    alt_env = mkAltEnv env scrut bndr-    occ_anal_alt = occAnalAlt alt_env--    occ_anal_scrut (Var v) (alt1 : other_alts)-        | not (null other_alts) || not (isDefaultAlt alt1)-        = (mkOneOcc env v IsInteresting 0, Var v)-            -- The 'True' says that the variable occurs in an interesting-            -- context; the case has at least one non-default alternative-    occ_anal_scrut (Tick t e) alts-        | t `tickishScopesLike` SoftScope-          -- No reason to not look through all ticks here, but only-          -- for soft-scoped ticks we can do so without having to-          -- update returned occurrence info (see occAnal)-        = second (Tick t) $ occ_anal_scrut e alts--    occ_anal_scrut scrut _alts-        = occAnal (vanillaCtxt env) scrut    -- No need for rhsCtxt--occAnal env (Let bind body)-  = case occAnal env body                of { (body_usage, body') ->-    case occAnalBind env NotTopLevel-                     noImpRuleEdges bind-                     body_usage          of { (final_usage, new_binds) ->-       (final_usage, mkLets new_binds body') }}--occAnalArgs :: OccEnv -> [CoreExpr] -> [OneShots] -> (UsageDetails, [CoreExpr])-occAnalArgs _ [] _-  = (emptyDetails, [])--occAnalArgs env (arg:args) one_shots-  | isTypeArg arg-  = case occAnalArgs env args one_shots of { (uds, args') ->-    (uds, arg:args') }--  | otherwise-  = case argCtxt env one_shots           of { (arg_env, one_shots') ->-    case occAnal arg_env arg             of { (uds1, arg') ->-    case occAnalArgs env args one_shots' of { (uds2, args') ->-    (uds1 `andUDs` uds2, arg':args') }}}--{--Applications are dealt with specially because we want-the "build hack" to work.--Note [Arguments of let-bound constructors]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-    f x = let y = expensive x in-          let z = (True,y) in-          (case z of {(p,q)->q}, case z of {(p,q)->q})-We feel free to duplicate the WHNF (True,y), but that means-that y may be duplicated thereby.--If we aren't careful we duplicate the (expensive x) call!-Constructors are rather like lambdas in this way.--}--occAnalApp :: OccEnv-           -> (Expr CoreBndr, [Arg CoreBndr], [Tickish Id])-           -> (UsageDetails, Expr CoreBndr)-occAnalApp env (Var fun, args, ticks)-  | null ticks = (uds, mkApps (Var fun) args')-  | otherwise  = (uds, mkTicks ticks $ mkApps (Var fun) args')-  where-    uds = fun_uds `andUDs` final_args_uds--    !(args_uds, args') = occAnalArgs env args one_shots-    !final_args_uds-       | isRhsEnv env && is_exp = markAllNonTailCalled $-                                  markAllInsideLam args_uds-       | otherwise              = markAllNonTailCalled args_uds-       -- We mark the free vars of the argument of a constructor or PAP-       -- as "inside-lambda", if it is the RHS of a let(rec).-       -- This means that nothing gets inlined into a constructor or PAP-       -- argument position, which is what we want.  Typically those-       -- constructor arguments are just variables, or trivial expressions.-       -- We use inside-lam because it's like eta-expanding the PAP.-       ---       -- This is the *whole point* of the isRhsEnv predicate-       -- See Note [Arguments of let-bound constructors]--    n_val_args = valArgCount args-    n_args     = length args-    fun_uds    = mkOneOcc env fun (if n_val_args > 0 then IsInteresting else NotInteresting) n_args-    is_exp     = isExpandableApp fun n_val_args-        -- See Note [CONLIKE pragma] in GHC.Types.Basic-        -- The definition of is_exp should match that in GHC.Core.Op.Simplify.prepareRhs--    one_shots  = argsOneShots (idStrictness fun) guaranteed_val_args-    guaranteed_val_args = n_val_args + length (takeWhile isOneShotInfo-                                                         (occ_one_shots env))-        -- See Note [Sources of one-shot information], bullet point A']--occAnalApp env (fun, args, ticks)-  = (markAllNonTailCalled (fun_uds `andUDs` args_uds),-     mkTicks ticks $ mkApps fun' args')-  where-    !(fun_uds, fun') = occAnal (addAppCtxt env args) fun-        -- The addAppCtxt is a bit cunning.  One iteration of the simplifier-        -- often leaves behind beta redexs like-        --      (\x y -> e) a1 a2-        -- Here we would like to mark x,y as one-shot, and treat the whole-        -- thing much like a let.  We do this by pushing some True items-        -- onto the context stack.-    !(args_uds, args') = occAnalArgs env args []--zapDetailsIf :: Bool              -- If this is true-             -> UsageDetails      -- Then do zapDetails on this-             -> UsageDetails-zapDetailsIf True  uds = zapDetails uds-zapDetailsIf False uds = uds--{--Note [Sources of one-shot information]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The occurrence analyser obtains one-shot-lambda information from two sources:--A:  Saturated applications:  eg   f e1 .. en--    In general, given a call (f e1 .. en) we can propagate one-shot info from-    f's strictness signature into e1 .. en, but /only/ if n is enough to-    saturate the strictness signature. A strictness signature like--          f :: C1(C1(L))LS--    means that *if f is applied to three arguments* then it will guarantee to-    call its first argument at most once, and to call the result of that at-    most once. But if f has fewer than three arguments, all bets are off; e.g.--          map (f (\x y. expensive) e2) xs--    Here the \x y abstraction may be called many times (once for each element of-    xs) so we should not mark x and y as one-shot. But if it was--          map (f (\x y. expensive) 3 2) xs--    then the first argument of f will be called at most once.--    The one-shot info, derived from f's strictness signature, is-    computed by 'argsOneShots', called in occAnalApp.--A': Non-obviously saturated applications: eg    build (f (\x y -> expensive))-    where f is as above.--    In this case, f is only manifestly applied to one argument, so it does not-    look saturated. So by the previous point, we should not use its strictness-    signature to learn about the one-shotness of \x y. But in this case we can:-    build is fully applied, so we may use its strictness signature; and from-    that we learn that build calls its argument with two arguments *at most once*.--    So there is really only one call to f, and it will have three arguments. In-    that sense, f is saturated, and we may proceed as described above.--    Hence the computation of 'guaranteed_val_args' in occAnalApp, using-    '(occ_one_shots env)'.  See also #13227, comment:9--B:  Let-bindings:  eg   let f = \c. let ... in \n -> blah-                        in (build f, build f)--    Propagate one-shot info from the demanand-info on 'f' to the-    lambdas in its RHS (which may not be syntactically at the top)--    This information must have come from a previous run of the demanand-    analyser.--Previously, the demand analyser would *also* set the one-shot information, but-that code was buggy (see #11770), so doing it only in on place, namely here, is-saner.--Note [OneShots]-~~~~~~~~~~~~~~~-When analysing an expression, the occ_one_shots argument contains information-about how the function is being used. The length of the list indicates-how many arguments will eventually be passed to the analysed expression,-and the OneShotInfo indicates whether this application is once or multiple times.--Example:-- Context of f                occ_one_shots when analysing f-- f 1 2                       [OneShot, OneShot]- map (f 1)                   [OneShot, NoOneShotInfo]- build f                     [OneShot, OneShot]- f 1 2 `seq` f 2 1           [NoOneShotInfo, OneShot]--Note [Binders in case alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-    case x of y { (a,b) -> f y }-We treat 'a', 'b' as dead, because they don't physically occur in the-case alternative.  (Indeed, a variable is dead iff it doesn't occur in-its scope in the output of OccAnal.)  It really helps to know when-binders are unused.  See esp the call to isDeadBinder in-Simplify.mkDupableAlt--In this example, though, the Simplifier will bring 'a' and 'b' back to-life, because it binds 'y' to (a,b) (imagine got inlined and-scrutinised y).--}--occAnalLamOrRhs :: OccEnv -> [CoreBndr] -> CoreExpr-                -> (UsageDetails, [CoreBndr], CoreExpr)-occAnalLamOrRhs env [] body-  = case occAnal env body of (body_usage, body') -> (body_usage, [], body')-      -- RHS of thunk or nullary join point-occAnalLamOrRhs env (bndr:bndrs) body-  | isTyVar bndr-  = -- Important: Keep the environment so that we don't inline into an RHS like-    --   \(@ x) -> C @x (f @x)-    -- (see the beginning of Note [Cascading inlines]).-    case occAnalLamOrRhs env bndrs body of-      (body_usage, bndrs', body') -> (body_usage, bndr:bndrs', body')-occAnalLamOrRhs env binders body-  = case occAnal env_body body of { (body_usage, body') ->-    let-        (final_usage, tagged_binders) = tagLamBinders body_usage binders'-                      -- Use binders' to put one-shot info on the lambdas-    in-    (final_usage, tagged_binders, body') }-  where-    (env_body, binders') = oneShotGroup env binders--occAnalAlt :: (OccEnv, Maybe (Id, CoreExpr))-           -> CoreAlt-           -> (UsageDetails, Alt IdWithOccInfo)-occAnalAlt (env, scrut_bind) (con, bndrs, rhs)-  = case occAnal env rhs of { (rhs_usage1, rhs1) ->-    let-      (alt_usg, tagged_bndrs) = tagLamBinders rhs_usage1 bndrs-                                -- See Note [Binders in case alternatives]-      (alt_usg', rhs2) = wrapAltRHS env scrut_bind alt_usg tagged_bndrs rhs1-    in-    (alt_usg', (con, tagged_bndrs, rhs2)) }--wrapAltRHS :: OccEnv-           -> Maybe (Id, CoreExpr)      -- proxy mapping generated by mkAltEnv-           -> UsageDetails              -- usage for entire alt (p -> rhs)-           -> [Var]                     -- alt binders-           -> CoreExpr                  -- alt RHS-           -> (UsageDetails, CoreExpr)-wrapAltRHS env (Just (scrut_var, let_rhs)) alt_usg bndrs alt_rhs-  | occ_binder_swap env-  , scrut_var `usedIn` alt_usg -- bndrs are not be present in alt_usg so this-                               -- handles condition (a) in Note [Binder swap]-  , not captured               -- See condition (b) in Note [Binder swap]-  = ( alt_usg' `andUDs` let_rhs_usg-    , Let (NonRec tagged_scrut_var let_rhs') alt_rhs )-  where-    captured = any (`usedIn` let_rhs_usg) bndrs  -- Check condition (b)--    -- The rhs of the let may include coercion variables-    -- if the scrutinee was a cast, so we must gather their-    -- usage. See Note [Gather occurrences of coercion variables]-    -- Moreover, the rhs of the let may mention the case-binder, and-    -- we want to gather its occ-info as well-    (let_rhs_usg, let_rhs') = occAnal env let_rhs--    (alt_usg', tagged_scrut_var) = tagLamBinder alt_usg scrut_var--wrapAltRHS _ _ alt_usg _ alt_rhs-  = (alt_usg, alt_rhs)--{--************************************************************************-*                                                                      *-                    OccEnv-*                                                                      *-************************************************************************--}--data OccEnv-  = OccEnv { occ_encl       :: !OccEncl      -- Enclosing context information-           , occ_one_shots  :: !OneShots     -- See Note [OneShots]-           , occ_gbl_scrut  :: GlobalScruts--           , occ_unf_act   :: Id -> Bool   -- Which Id unfoldings are active--           , occ_rule_act   :: Activation -> Bool   -- Which rules are active-             -- See Note [Finding rule RHS free vars]--           , occ_binder_swap :: !Bool -- enable the binder_swap-             -- See CorePrep Note [Dead code in CorePrep]-    }--type GlobalScruts = IdSet   -- See Note [Binder swap on GlobalId scrutinees]---------------------------------- OccEncl is used to control whether to inline into constructor arguments--- For example:---      x = (p,q)               -- Don't inline p or q---      y = /\a -> (p a, q a)   -- Still don't inline p or q---      z = f (p,q)             -- Do inline p,q; it may make a rule fire--- So OccEncl tells enough about the context to know what to do when--- we encounter a constructor application or PAP.--data OccEncl-  = OccRhs              -- RHS of let(rec), albeit perhaps inside a type lambda-                        -- Don't inline into constructor args here-  | OccVanilla          -- Argument of function, body of lambda, scruintee of case etc.-                        -- Do inline into constructor args here--instance Outputable OccEncl where-  ppr OccRhs     = text "occRhs"-  ppr OccVanilla = text "occVanilla"---- See note [OneShots]-type OneShots = [OneShotInfo]--initOccEnv :: OccEnv-initOccEnv-  = OccEnv { occ_encl      = OccVanilla-           , occ_one_shots = []-           , occ_gbl_scrut = emptyVarSet-                 -- To be conservative, we say that all-                 -- inlines and rules are active-           , occ_unf_act   = \_ -> True-           , occ_rule_act  = \_ -> True-           , occ_binder_swap = True }--vanillaCtxt :: OccEnv -> OccEnv-vanillaCtxt env = env { occ_encl = OccVanilla, occ_one_shots = [] }--rhsCtxt :: OccEnv -> OccEnv-rhsCtxt env = env { occ_encl = OccRhs, occ_one_shots = [] }--argCtxt :: OccEnv -> [OneShots] -> (OccEnv, [OneShots])-argCtxt env []-  = (env { occ_encl = OccVanilla, occ_one_shots = [] }, [])-argCtxt env (one_shots:one_shots_s)-  = (env { occ_encl = OccVanilla, occ_one_shots = one_shots }, one_shots_s)--isRhsEnv :: OccEnv -> Bool-isRhsEnv (OccEnv { occ_encl = OccRhs })     = True-isRhsEnv (OccEnv { occ_encl = OccVanilla }) = False--oneShotGroup :: OccEnv -> [CoreBndr]-             -> ( OccEnv-                , [CoreBndr] )-        -- The result binders have one-shot-ness set that they might not have had originally.-        -- This happens in (build (\c n -> e)).  Here the occurrence analyser-        -- linearity context knows that c,n are one-shot, and it records that fact in-        -- the binder. This is useful to guide subsequent float-in/float-out transformations--oneShotGroup env@(OccEnv { occ_one_shots = ctxt }) bndrs-  = go ctxt bndrs []-  where-    go ctxt [] rev_bndrs-      = ( env { occ_one_shots = ctxt, occ_encl = OccVanilla }-        , reverse rev_bndrs )--    go [] bndrs rev_bndrs-      = ( env { occ_one_shots = [], occ_encl = OccVanilla }-        , reverse rev_bndrs ++ bndrs )--    go ctxt@(one_shot : ctxt') (bndr : bndrs) rev_bndrs-      | isId bndr = go ctxt' bndrs (bndr': rev_bndrs)-      | otherwise = go ctxt  bndrs (bndr : rev_bndrs)-      where-        bndr' = updOneShotInfo bndr one_shot-               -- Use updOneShotInfo, not setOneShotInfo, as pre-existing-               -- one-shot info might be better than what we can infer, e.g.-               -- due to explicit use of the magic 'oneShot' function.-               -- See Note [The oneShot function]---markJoinOneShots :: Maybe JoinArity -> [Var] -> [Var]--- Mark the lambdas of a non-recursive join point as one-shot.--- This is good to prevent gratuitous float-out etc-markJoinOneShots mb_join_arity bndrs-  = case mb_join_arity of-      Nothing -> bndrs-      Just n  -> go n bndrs- where-   go 0 bndrs  = bndrs-   go _ []     = [] -- This can legitimately happen.-                    -- e.g.    let j = case ... in j True-                    -- This will become an arity-1 join point after the-                    -- simplifier has eta-expanded it; but it may not have-                    -- enough lambdas /yet/. (Lint checks that JoinIds do-                    -- have enough lambdas.)-   go n (b:bs) = b' : go (n-1) bs-     where-       b' | isId b    = setOneShotLambda b-          | otherwise = b--addAppCtxt :: OccEnv -> [Arg CoreBndr] -> OccEnv-addAppCtxt env@(OccEnv { occ_one_shots = ctxt }) args-  = env { occ_one_shots = replicate (valArgCount args) OneShotLam ++ ctxt }--transClosureFV :: UniqFM VarSet -> UniqFM VarSet--- If (f,g), (g,h) are in the input, then (f,h) is in the output---                                   as well as (f,g), (g,h)-transClosureFV env-  | no_change = env-  | otherwise = transClosureFV (listToUFM new_fv_list)-  where-    (no_change, new_fv_list) = mapAccumL bump True (nonDetUFMToList env)-      -- It's OK to use nonDetUFMToList here because we'll forget the-      -- ordering by creating a new set with listToUFM-    bump no_change (b,fvs)-      | no_change_here = (no_change, (b,fvs))-      | otherwise      = (False,     (b,new_fvs))-      where-        (new_fvs, no_change_here) = extendFvs env fvs----------------extendFvs_ :: UniqFM VarSet -> VarSet -> VarSet-extendFvs_ env s = fst (extendFvs env s)   -- Discard the Bool flag--extendFvs :: UniqFM VarSet -> VarSet -> (VarSet, Bool)--- (extendFVs env s) returns---     (s `union` env(s), env(s) `subset` s)-extendFvs env s-  | isNullUFM env-  = (s, True)-  | otherwise-  = (s `unionVarSet` extras, extras `subVarSet` s)-  where-    extras :: VarSet    -- env(s)-    extras = nonDetFoldUFM unionVarSet emptyVarSet $-      -- It's OK to use nonDetFoldUFM here because unionVarSet commutes-             intersectUFM_C (\x _ -> x) env (getUniqSet s)--{--************************************************************************-*                                                                      *-                    Binder swap-*                                                                      *-************************************************************************--Note [Binder swap]-~~~~~~~~~~~~~~~~~~-The "binder swap" transformation swaps occurrence of the-scrutinee of a case for occurrences of the case-binder:-- (1)  case x of b { pi -> ri }-         ==>-      case x of b { pi -> let x=b in ri }-- (2)  case (x |> co) of b { pi -> ri }-        ==>-      case (x |> co) of b { pi -> let x = b |> sym co in ri }--In both cases, the trivial 'let' can be eliminated by the-immediately following simplifier pass.--There are two reasons for making this swap:--(A) It reduces the number of occurrences of the scrutinee, x.-    That in turn might reduce its occurrences to one, so we-    can inline it and save an allocation.  E.g.-      let x = factorial y in case x of b { I# v -> ...x... }-    If we replace 'x' by 'b' in the alternative we get-      let x = factorial y in case x of b { I# v -> ...b... }-    and now we can inline 'x', thus-      case (factorial y) of b { I# v -> ...b... }--(B) The case-binder b has unfolding information; in the-    example above we know that b = I# v. That in turn allows-    nested cases to simplify.  Consider-       case x of b { I# v ->-       ...(case x of b2 { I# v2 -> rhs })...-    If we replace 'x' by 'b' in the alternative we get-       case x of b { I# v ->-       ...(case b of b2 { I# v2 -> rhs })...-    and now it is trivial to simplify the inner case:-       case x of b { I# v ->-       ...(let b2 = b in rhs)...--    The same can happen even if the scrutinee is a variable-    with a cast: see Note [Case of cast]--In both cases, in a particular alternative (pi -> ri), we only-add the binding if-  (a) x occurs free in (pi -> ri)-        (ie it occurs in ri, but is not bound in pi)-  (b) the pi does not bind b (or the free vars of co)-We need (a) and (b) for the inserted binding to be correct.--For the alternatives where we inject the binding, we can transfer-all x's OccInfo to b.  And that is the point.--Notice that-  * The deliberate shadowing of 'x'.-  * That (a) rapidly becomes false, so no bindings are injected.--The reason for doing these transformations /here in the occurrence-analyser/ is because it allows us to adjust the OccInfo for 'x' and-'b' as we go.--  * Suppose the only occurrences of 'x' are the scrutinee and in the-    ri; then this transformation makes it occur just once, and hence-    get inlined right away.--  * If instead we do this in the Simplifier, we don't know whether 'x'-    is used in ri, so we are forced to pessimistically zap b's OccInfo-    even though it is typically dead (ie neither it nor x appear in-    the ri).  There's nothing actually wrong with zapping it, except-    that it's kind of nice to know which variables are dead.  My nose-    tells me to keep this information as robustly as possible.--The Maybe (Id,CoreExpr) passed to occAnalAlt is the extra let-binding-{x=b}; it's Nothing if the binder-swap doesn't happen.--There is a danger though.  Consider-      let v = x +# y-      in case (f v) of w -> ...v...v...-And suppose that (f v) expands to just v.  Then we'd like to-use 'w' instead of 'v' in the alternative.  But it may be too-late; we may have substituted the (cheap) x+#y for v in the-same simplifier pass that reduced (f v) to v.--I think this is just too bad.  CSE will recover some of it.--Note [Case of cast]-~~~~~~~~~~~~~~~~~~~-Consider        case (x `cast` co) of b { I# ->-                ... (case (x `cast` co) of {...}) ...-We'd like to eliminate the inner case.  That is the motivation for-equation (2) in Note [Binder swap].  When we get to the inner case, we-inline x, cancel the casts, and away we go.--Note [Binder swap on GlobalId scrutinees]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When the scrutinee is a GlobalId we must take care in two ways-- i) In order to *know* whether 'x' occurs free in the RHS, we need its-    occurrence info. BUT, we don't gather occurrence info for-    GlobalIds.  That's the reason for the (small) occ_gbl_scrut env in-    OccEnv is for: it says "gather occurrence info for these".-- ii) We must call localiseId on 'x' first, in case it's a GlobalId, or-     has an External Name. See, for example, SimplEnv Note [Global Ids in-     the substitution].--Note [Zap case binders in proxy bindings]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-From the original-     case x of cb(dead) { p -> ...x... }-we will get-     case x of cb(live) { p -> let x = cb in ...x... }--Core Lint never expects to find an *occurrence* of an Id marked-as Dead, so we must zap the OccInfo on cb before making the-binding x = cb.  See #5028.--NB: the OccInfo on /occurrences/ really doesn't matter much; the simplifier-doesn't use it. So this is only to satisfy the perhaps-over-picky Lint.--Historical note [no-case-of-case]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We *used* to suppress the binder-swap in case expressions when--fno-case-of-case is on.  Old remarks:-    "This happens in the first simplifier pass,-    and enhances full laziness.  Here's the bad case:-            f = \ y -> ...(case x of I# v -> ...(case x of ...) ... )-    If we eliminate the inner case, we trap it inside the I# v -> arm,-    which might prevent some full laziness happening.  I've seen this-    in action in spectral/cichelli/Prog.hs:-             [(m,n) | m <- [1..max], n <- [1..max]]-    Hence the check for NoCaseOfCase."-However, now the full-laziness pass itself reverses the binder-swap, so this-check is no longer necessary.--Historical note [Suppressing the case binder-swap]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-This old note describes a problem that is also fixed by doing the-binder-swap in OccAnal:--    There is another situation when it might make sense to suppress the-    case-expression binde-swap. If we have--        case x of w1 { DEFAULT -> case x of w2 { A -> e1; B -> e2 }-                       ...other cases .... }--    We'll perform the binder-swap for the outer case, giving--        case x of w1 { DEFAULT -> case w1 of w2 { A -> e1; B -> e2 }-                       ...other cases .... }--    But there is no point in doing it for the inner case, because w1 can't-    be inlined anyway.  Furthermore, doing the case-swapping involves-    zapping w2's occurrence info (see paragraphs that follow), and that-    forces us to bind w2 when doing case merging.  So we get--        case x of w1 { A -> let w2 = w1 in e1-                       B -> let w2 = w1 in e2-                       ...other cases .... }--    This is plain silly in the common case where w2 is dead.--    Even so, I can't see a good way to implement this idea.  I tried-    not doing the binder-swap if the scrutinee was already evaluated-    but that failed big-time:--            data T = MkT !Int--            case v of w  { MkT x ->-            case x of x1 { I# y1 ->-            case x of x2 { I# y2 -> ...--    Notice that because MkT is strict, x is marked "evaluated".  But to-    eliminate the last case, we must either make sure that x (as well as-    x1) has unfolding MkT y1.  The straightforward thing to do is to do-    the binder-swap.  So this whole note is a no-op.--It's fixed by doing the binder-swap in OccAnal because we can do the-binder-swap unconditionally and still get occurrence analysis-information right.--}--mkAltEnv :: OccEnv -> CoreExpr -> Id -> (OccEnv, Maybe (Id, CoreExpr))--- Does three things: a) makes the occ_one_shots = OccVanilla---                    b) extends the GlobalScruts if possible---                    c) returns a proxy mapping, binding the scrutinee---                       to the case binder, if possible-mkAltEnv env@(OccEnv { occ_gbl_scrut = pe }) scrut case_bndr-  = case stripTicksTopE (const True) scrut of-      Var v           -> add_scrut v case_bndr'-      Cast (Var v) co -> add_scrut v (Cast case_bndr' (mkSymCo co))-                          -- See Note [Case of cast]-      _               -> (env { occ_encl = OccVanilla }, Nothing)--  where-    add_scrut v rhs-      | isGlobalId v = (env { occ_encl = OccVanilla }, Nothing)-      | otherwise    = ( env { occ_encl = OccVanilla-                             , occ_gbl_scrut = pe `extendVarSet` v }-                       , Just (localise v, rhs) )-      -- ToDO: this isGlobalId stuff is a TEMPORARY FIX-      --       to avoid the binder-swap for GlobalIds-      --       See #16346--    case_bndr' = Var (zapIdOccInfo case_bndr)-                   -- See Note [Zap case binders in proxy bindings]--    -- Localise the scrut_var before shadowing it; we're making a-    -- new binding for it, and it might have an External Name, or-    -- even be a GlobalId; Note [Binder swap on GlobalId scrutinees]-    -- Also we don't want any INLINE or NOINLINE pragmas!-    localise scrut_var = mkLocalIdOrCoVar (localiseName (idName scrut_var))-                                          (idType scrut_var)--{--************************************************************************-*                                                                      *-\subsection[OccurAnal-types]{OccEnv}-*                                                                      *-************************************************************************--Note [UsageDetails and zapping]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--On many occasions, we must modify all gathered occurrence data at once. For-instance, all occurrences underneath a (non-one-shot) lambda set the-'occ_in_lam' flag to become 'True'. We could use 'mapVarEnv' to do this, but-that takes O(n) time and we will do this often---in particular, there are many-places where tail calls are not allowed, and each of these causes all variables-to get marked with 'NoTailCallInfo'.--Instead of relying on `mapVarEnv`, then, we carry three 'IdEnv's around along-with the 'OccInfoEnv'. Each of these extra environments is a "zapped set"-recording which variables have been zapped in some way. Zapping all occurrence-info then simply means setting the corresponding zapped set to the whole-'OccInfoEnv', a fast O(1) operation.--}--type OccInfoEnv = IdEnv OccInfo -- A finite map from ids to their usage-                -- INVARIANT: never IAmDead-                -- (Deadness is signalled by not being in the map at all)--type ZappedSet = OccInfoEnv -- Values are ignored--data UsageDetails-  = UD { ud_env       :: !OccInfoEnv-       , ud_z_many    :: ZappedSet   -- apply 'markMany' to these-       , ud_z_in_lam  :: ZappedSet   -- apply 'markInsideLam' to these-       , ud_z_no_tail :: ZappedSet } -- apply 'markNonTailCalled' to these-  -- INVARIANT: All three zapped sets are subsets of the OccInfoEnv--instance Outputable UsageDetails where-  ppr ud = ppr (ud_env (flattenUsageDetails ud))------------------------ UsageDetails API--andUDs, orUDs-        :: UsageDetails -> UsageDetails -> UsageDetails-andUDs = combineUsageDetailsWith addOccInfo-orUDs  = combineUsageDetailsWith orOccInfo--andUDsList :: [UsageDetails] -> UsageDetails-andUDsList = foldl' andUDs emptyDetails--mkOneOcc :: OccEnv -> Id -> InterestingCxt -> JoinArity -> UsageDetails-mkOneOcc env id int_cxt arity-  | isLocalId id-  = singleton $ OneOcc { occ_in_lam  = NotInsideLam-                       , occ_one_br  = InOneBranch-                       , occ_int_cxt = int_cxt-                       , occ_tail    = AlwaysTailCalled arity }-  | id `elemVarSet` occ_gbl_scrut env-  = singleton noOccInfo--  | otherwise-  = emptyDetails-  where-    singleton info = emptyDetails { ud_env = unitVarEnv id info }--addOneOcc :: UsageDetails -> Id -> OccInfo -> UsageDetails-addOneOcc ud id info-  = ud { ud_env = extendVarEnv_C plus_zapped (ud_env ud) id info }-      `alterZappedSets` (`delVarEnv` id)-  where-    plus_zapped old new = doZapping ud id old `addOccInfo` new--addManyOccsSet :: UsageDetails -> VarSet -> UsageDetails-addManyOccsSet usage id_set = nonDetFoldUniqSet addManyOccs usage id_set-  -- It's OK to use nonDetFoldUFM here because addManyOccs commutes---- Add several occurrences, assumed not to be tail calls-addManyOccs :: Var -> UsageDetails -> UsageDetails-addManyOccs v u | isId v    = addOneOcc u v noOccInfo-                | otherwise = u-        -- Give a non-committal binder info (i.e noOccInfo) because-        --   a) Many copies of the specialised thing can appear-        --   b) We don't want to substitute a BIG expression inside a RULE-        --      even if that's the only occurrence of the thing-        --      (Same goes for INLINE.)--delDetails :: UsageDetails -> Id -> UsageDetails-delDetails ud bndr-  = ud `alterUsageDetails` (`delVarEnv` bndr)--delDetailsList :: UsageDetails -> [Id] -> UsageDetails-delDetailsList ud bndrs-  = ud `alterUsageDetails` (`delVarEnvList` bndrs)--emptyDetails :: UsageDetails-emptyDetails = UD { ud_env       = emptyVarEnv-                  , ud_z_many    = emptyVarEnv-                  , ud_z_in_lam  = emptyVarEnv-                  , ud_z_no_tail = emptyVarEnv }--isEmptyDetails :: UsageDetails -> Bool-isEmptyDetails = isEmptyVarEnv . ud_env--markAllMany, markAllInsideLam, markAllNonTailCalled, zapDetails-  :: UsageDetails -> UsageDetails-markAllMany          ud = ud { ud_z_many    = ud_env ud }-markAllInsideLam     ud = ud { ud_z_in_lam  = ud_env ud }-markAllNonTailCalled ud = ud { ud_z_no_tail = ud_env ud }--zapDetails = markAllMany . markAllNonTailCalled -- effectively sets to noOccInfo--lookupDetails :: UsageDetails -> Id -> OccInfo-lookupDetails ud id-  | isCoVar id  -- We do not currently gather occurrence info (from types)-  = noOccInfo   -- for CoVars, so we must conservatively mark them as used-                -- See Note [DoO not mark CoVars as dead]-  | otherwise-  = case lookupVarEnv (ud_env ud) id of-      Just occ -> doZapping ud id occ-      Nothing  -> IAmDead--usedIn :: Id -> UsageDetails -> Bool-v `usedIn` ud = isExportedId v || v `elemVarEnv` ud_env ud--udFreeVars :: VarSet -> UsageDetails -> VarSet--- Find the subset of bndrs that are mentioned in uds-udFreeVars bndrs ud = restrictUniqSetToUFM bndrs (ud_env ud)--{- Note [Do not mark CoVars as dead]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-It's obviously wrong to mark CoVars as dead if they are used.-Currently we don't traverse types to gather usase info for CoVars,-so we had better treat them as having noOccInfo.--This showed up in #15696 we had something like-  case eq_sel d of co -> ...(typeError @(...co...) "urk")...--Then 'd' was substituted by a dictionary, so the expression-simpified to-  case (Coercion <blah>) of co -> ...(typeError @(...co...) "urk")...--But then the "drop the case altogether" equation of rebuildCase-thought that 'co' was dead, and discarded the entire case. Urk!--I have no idea how we managed to avoid this pitfall for so long!--}------------------------ Auxiliary functions for UsageDetails implementation--combineUsageDetailsWith :: (OccInfo -> OccInfo -> OccInfo)-                        -> UsageDetails -> UsageDetails -> UsageDetails-combineUsageDetailsWith plus_occ_info ud1 ud2-  | isEmptyDetails ud1 = ud2-  | isEmptyDetails ud2 = ud1-  | otherwise-  = UD { ud_env       = plusVarEnv_C plus_occ_info (ud_env ud1) (ud_env ud2)-       , ud_z_many    = plusVarEnv (ud_z_many    ud1) (ud_z_many    ud2)-       , ud_z_in_lam  = plusVarEnv (ud_z_in_lam  ud1) (ud_z_in_lam  ud2)-       , ud_z_no_tail = plusVarEnv (ud_z_no_tail ud1) (ud_z_no_tail ud2) }--doZapping :: UsageDetails -> Var -> OccInfo -> OccInfo-doZapping ud var occ-  = doZappingByUnique ud (varUnique var) occ--doZappingByUnique :: UsageDetails -> Unique -> OccInfo -> OccInfo-doZappingByUnique ud uniq-  = (if | in_subset ud_z_many    -> markMany-        | in_subset ud_z_in_lam  -> markInsideLam-        | otherwise              -> id) .-    (if | in_subset ud_z_no_tail -> markNonTailCalled-        | otherwise              -> id)-  where-    in_subset field = uniq `elemVarEnvByKey` field ud--alterZappedSets :: UsageDetails -> (ZappedSet -> ZappedSet) -> UsageDetails-alterZappedSets ud f-  = ud { ud_z_many    = f (ud_z_many    ud)-       , ud_z_in_lam  = f (ud_z_in_lam  ud)-       , ud_z_no_tail = f (ud_z_no_tail ud) }--alterUsageDetails :: UsageDetails -> (OccInfoEnv -> OccInfoEnv) -> UsageDetails-alterUsageDetails ud f-  = ud { ud_env = f (ud_env ud) }-      `alterZappedSets` f--flattenUsageDetails :: UsageDetails -> UsageDetails-flattenUsageDetails ud-  = ud { ud_env = mapUFM_Directly (doZappingByUnique ud) (ud_env ud) }-      `alterZappedSets` const emptyVarEnv------------------------ See Note [Adjusting right-hand sides]-adjustRhsUsage :: Maybe JoinArity -> RecFlag-               -> [CoreBndr] -- Outer lambdas, AFTER occ anal-               -> UsageDetails -> UsageDetails-adjustRhsUsage mb_join_arity rec_flag bndrs usage-  = maybe_mark_lam (maybe_drop_tails usage)-  where-    maybe_mark_lam ud   | one_shot   = ud-                        | otherwise  = markAllInsideLam ud-    maybe_drop_tails ud | exact_join = ud-                        | otherwise  = markAllNonTailCalled ud--    one_shot = case mb_join_arity of-                 Just join_arity-                   | isRec rec_flag -> False-                   | otherwise      -> all isOneShotBndr (drop join_arity bndrs)-                 Nothing            -> all isOneShotBndr bndrs--    exact_join = case mb_join_arity of-                   Just join_arity -> bndrs `lengthIs` join_arity-                   _               -> False--type IdWithOccInfo = Id--tagLamBinders :: UsageDetails          -- Of scope-              -> [Id]                  -- Binders-              -> (UsageDetails,        -- Details with binders removed-                 [IdWithOccInfo])    -- Tagged binders-tagLamBinders usage binders-  = usage' `seq` (usage', bndrs')-  where-    (usage', bndrs') = mapAccumR tagLamBinder usage binders--tagLamBinder :: UsageDetails       -- Of scope-             -> Id                 -- Binder-             -> (UsageDetails,     -- Details with binder removed-                 IdWithOccInfo)    -- Tagged binders--- Used for lambda and case binders--- It copes with the fact that lambda bindings can have a--- stable unfolding, used for join points-tagLamBinder usage bndr-  = (usage2, bndr')-  where-        occ    = lookupDetails usage bndr-        bndr'  = setBinderOcc (markNonTailCalled occ) bndr-                   -- Don't try to make an argument into a join point-        usage1 = usage `delDetails` bndr-        usage2 | isId bndr = addManyOccsSet usage1 (idUnfoldingVars bndr)-                               -- This is effectively the RHS of a-                               -- non-join-point binding, so it's okay to use-                               -- addManyOccsSet, which assumes no tail calls-               | otherwise = usage1--tagNonRecBinder :: TopLevelFlag           -- At top level?-                -> UsageDetails           -- Of scope-                -> CoreBndr               -- Binder-                -> (UsageDetails,         -- Details with binder removed-                    IdWithOccInfo)        -- Tagged binder--tagNonRecBinder lvl usage binder- = let-     occ     = lookupDetails usage binder-     will_be_join = decideJoinPointHood lvl usage [binder]-     occ'    | will_be_join = -- must already be marked AlwaysTailCalled-                              ASSERT(isAlwaysTailCalled occ) occ-             | otherwise    = markNonTailCalled occ-     binder' = setBinderOcc occ' binder-     usage'  = usage `delDetails` binder-   in-   usage' `seq` (usage', binder')--tagRecBinders :: TopLevelFlag           -- At top level?-              -> UsageDetails           -- Of body of let ONLY-              -> [(CoreBndr,            -- Binder-                   UsageDetails,        -- RHS usage details-                   [CoreBndr])]         -- Lambdas in new RHS-              -> (UsageDetails,         -- Adjusted details for whole scope,-                                        -- with binders removed-                  [IdWithOccInfo])      -- Tagged binders--- Substantially more complicated than non-recursive case. Need to adjust RHS--- details *before* tagging binders (because the tags depend on the RHSes).-tagRecBinders lvl body_uds triples- = let-     (bndrs, rhs_udss, _) = unzip3 triples--     -- 1. Determine join-point-hood of whole group, as determined by-     --    the *unadjusted* usage details-     unadj_uds     = foldr andUDs body_uds rhs_udss-     will_be_joins = decideJoinPointHood lvl unadj_uds bndrs--     -- 2. Adjust usage details of each RHS, taking into account the-     --    join-point-hood decision-     rhs_udss' = map adjust triples-     adjust (bndr, rhs_uds, rhs_bndrs)-       = adjustRhsUsage mb_join_arity Recursive rhs_bndrs rhs_uds-       where-         -- Can't use willBeJoinId_maybe here because we haven't tagged the-         -- binder yet (the tag depends on these adjustments!)-         mb_join_arity-           | will_be_joins-           , let occ = lookupDetails unadj_uds bndr-           , AlwaysTailCalled arity <- tailCallInfo occ-           = Just arity-           | otherwise-           = ASSERT(not will_be_joins) -- Should be AlwaysTailCalled if-             Nothing                   -- we are making join points!--     -- 3. Compute final usage details from adjusted RHS details-     adj_uds   = foldr andUDs body_uds rhs_udss'--     -- 4. Tag each binder with its adjusted details-     bndrs'    = [ setBinderOcc (lookupDetails adj_uds bndr) bndr-                 | bndr <- bndrs ]--     -- 5. Drop the binders from the adjusted details and return-     usage'    = adj_uds `delDetailsList` bndrs-   in-   (usage', bndrs')--setBinderOcc :: OccInfo -> CoreBndr -> CoreBndr-setBinderOcc occ_info bndr-  | isTyVar bndr      = bndr-  | isExportedId bndr = if isManyOccs (idOccInfo bndr)-                          then bndr-                          else setIdOccInfo bndr noOccInfo-            -- Don't use local usage info for visible-elsewhere things-            -- BUT *do* erase any IAmALoopBreaker annotation, because we're-            -- about to re-generate it and it shouldn't be "sticky"--  | otherwise = setIdOccInfo bndr occ_info---- | Decide whether some bindings should be made into join points or not.--- Returns `False` if they can't be join points. Note that it's an--- all-or-nothing decision, as if multiple binders are given, they're--- assumed to be mutually recursive.------ It must, however, be a final decision. If we say "True" for 'f',--- and then subsequently decide /not/ make 'f' into a join point, then--- the decision about another binding 'g' might be invalidated if (say)--- 'f' tail-calls 'g'.------ See Note [Invariants on join points] in GHC.Core.-decideJoinPointHood :: TopLevelFlag -> UsageDetails-                    -> [CoreBndr]-                    -> Bool-decideJoinPointHood TopLevel _ _-  = False-decideJoinPointHood NotTopLevel usage bndrs-  | isJoinId (head bndrs)-  = WARN(not all_ok, text "OccurAnal failed to rediscover join point(s):" <+>-                       ppr bndrs)-    all_ok-  | otherwise-  = all_ok-  where-    -- See Note [Invariants on join points]; invariants cited by number below.-    -- Invariant 2 is always satisfiable by the simplifier by eta expansion.-    all_ok = -- Invariant 3: Either all are join points or none are-             all ok bndrs--    ok bndr-      | -- Invariant 1: Only tail calls, all same join arity-        AlwaysTailCalled arity <- tailCallInfo (lookupDetails usage bndr)--      , -- Invariant 1 as applied to LHSes of rules-        all (ok_rule arity) (idCoreRules bndr)--        -- Invariant 2a: stable unfoldings-        -- See Note [Join points and INLINE pragmas]-      , ok_unfolding arity (realIdUnfolding bndr)--        -- Invariant 4: Satisfies polymorphism rule-      , isValidJoinPointType arity (idType bndr)-      = True--      | otherwise-      = False--    ok_rule _ BuiltinRule{} = False -- only possible with plugin shenanigans-    ok_rule join_arity (Rule { ru_args = args })-      = args `lengthIs` join_arity-        -- Invariant 1 as applied to LHSes of rules--    -- ok_unfolding returns False if we should /not/ convert a non-join-id-    -- into a join-id, even though it is AlwaysTailCalled-    ok_unfolding join_arity (CoreUnfolding { uf_src = src, uf_tmpl = rhs })-      = not (isStableSource src && join_arity > joinRhsArity rhs)-    ok_unfolding _ (DFunUnfolding {})-      = False-    ok_unfolding _ _-      = True--willBeJoinId_maybe :: CoreBndr -> Maybe JoinArity-willBeJoinId_maybe bndr-  = case tailCallInfo (idOccInfo bndr) of-      AlwaysTailCalled arity -> Just arity-      _                      -> isJoinId_maybe bndr---{- Note [Join points and INLINE pragmas]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-   f x = let g = \x. not  -- Arity 1-             {-# INLINE g #-}-         in case x of-              A -> g True True-              B -> g True False-              C -> blah2--Here 'g' is always tail-called applied to 2 args, but the stable-unfolding captured by the INLINE pragma has arity 1.  If we try to-convert g to be a join point, its unfolding will still have arity 1-(since it is stable, and we don't meddle with stable unfoldings), and-Lint will complain (see Note [Invariants on join points], (2a), in-GHC.Core.  #13413.--Moreover, since g is going to be inlined anyway, there is no benefit-from making it a join point.--If it is recursive, and uselessly marked INLINE, this will stop us-making it a join point, which is annoying.  But occasionally-(notably in class methods; see Note [Instances and loop breakers] in-TcInstDcls) we mark recursive things as INLINE but the recursion-unravels; so ignoring INLINE pragmas on recursive things isn't good-either.--See Invariant 2a of Note [Invariants on join points] in GHC.Core---************************************************************************-*                                                                      *-\subsection{Operations over OccInfo}-*                                                                      *-************************************************************************--}--markMany, markInsideLam, markNonTailCalled :: OccInfo -> OccInfo--markMany IAmDead = IAmDead-markMany occ     = ManyOccs { occ_tail = occ_tail occ }--markInsideLam occ@(OneOcc {}) = occ { occ_in_lam = IsInsideLam }-markInsideLam occ             = occ--markNonTailCalled IAmDead = IAmDead-markNonTailCalled occ     = occ { occ_tail = NoTailCallInfo }--addOccInfo, orOccInfo :: OccInfo -> OccInfo -> OccInfo--addOccInfo a1 a2  = ASSERT( not (isDeadOcc a1 || isDeadOcc a2) )-                    ManyOccs { occ_tail = tailCallInfo a1 `andTailCallInfo`-                                          tailCallInfo a2 }-                                -- Both branches are at least One-                                -- (Argument is never IAmDead)---- (orOccInfo orig new) is used--- when combining occurrence info from branches of a case--orOccInfo (OneOcc { occ_in_lam = in_lam1, occ_int_cxt = int_cxt1-                  , occ_tail   = tail1 })-          (OneOcc { occ_in_lam = in_lam2, occ_int_cxt = int_cxt2-                  , occ_tail   = tail2 })-  = OneOcc { occ_one_br  = MultipleBranches -- because it occurs in both branches-           , occ_in_lam  = in_lam1 `mappend` in_lam2-           , occ_int_cxt = int_cxt1 `mappend` int_cxt2-           , occ_tail    = tail1 `andTailCallInfo` tail2 }--orOccInfo a1 a2 = ASSERT( not (isDeadOcc a1 || isDeadOcc a2) )-                  ManyOccs { occ_tail = tailCallInfo a1 `andTailCallInfo`-                                        tailCallInfo a2 }--andTailCallInfo :: TailCallInfo -> TailCallInfo -> TailCallInfo-andTailCallInfo info@(AlwaysTailCalled arity1) (AlwaysTailCalled arity2)-  | arity1 == arity2 = info-andTailCallInfo _ _  = NoTailCallInfo
− compiler/GHC/Core/Op/Tidy.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 GHC.Core.Op.Tidy (-        tidyExpr, tidyRules, tidyUnfolding-    ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.Core-import GHC.Core.Seq ( seqUnfolding )-import GHC.Types.Id-import GHC.Types.Id.Info-import GHC.Types.Demand ( zapUsageEnvSig )-import GHC.Core.Type     ( tidyType, tidyVarBndr )-import GHC.Core.Coercion ( tidyCo )-import GHC.Types.Var-import GHC.Types.Var.Env-import GHC.Types.Unique.FM-import GHC.Types.Name hiding (tidyNameOcc)-import GHC.Types.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 GHC.Core.Op.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 GHC.Types.Id.Make.--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/Opt/ConstantFold.hs view
@@ -0,0 +1,2254 @@+{-+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++\section[ConFold]{Constant Folder}++Conceptually, constant folding should be parameterized with the kind+of target machine to get identical behaviour during compilation time+and runtime. We cheat a little bit here...++ToDo:+   check boundaries before folding, e.g. we can fold the Float addition+   (i1 + i2) only if it results in a valid Float.+-}++{-# LANGUAGE CPP, RankNTypes, PatternSynonyms, ViewPatterns, RecordWildCards,+    DeriveFunctor #-}+{-# LANGUAGE LambdaCase #-}+{-# OPTIONS_GHC -optc-DNON_POSIX_SOURCE -Wno-incomplete-uni-patterns #-}++module GHC.Core.Opt.ConstantFold+   ( primOpRules+   , builtinRules+   , caseRules+   )+where++#include "HsVersions.h"++import GHC.Prelude++import {-# SOURCE #-} GHC.Types.Id.Make ( mkPrimOpId, magicDictId )++import GHC.Core+import GHC.Core.Make+import GHC.Types.Id+import GHC.Types.Literal+import GHC.Core.SimpleOpt ( exprIsLiteral_maybe )+import GHC.Builtin.PrimOps ( PrimOp(..), tagToEnumKey )+import GHC.Builtin.Types+import GHC.Builtin.Types.Prim+import GHC.Core.TyCon+   ( tyConDataCons_maybe, isAlgTyCon, isEnumerationTyCon+   , isNewTyCon, unwrapNewTyCon_maybe, tyConDataCons+   , tyConFamilySize )+import GHC.Core.DataCon ( dataConTagZ, dataConTyCon, dataConWrapId, dataConWorkId )+import GHC.Core.Utils  ( cheapEqExpr, cheapEqExpr', exprIsHNF, exprType+                       , stripTicksTop, stripTicksTopT, mkTicks )+import GHC.Core.Unfold ( exprIsConApp_maybe )+import GHC.Core.Type+import GHC.Types.Name.Occurrence ( occNameFS )+import GHC.Builtin.Names+import GHC.Data.Maybe      ( orElse )+import GHC.Types.Name ( Name, nameOccName )+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Types.Basic+import GHC.Platform+import GHC.Utils.Misc+import GHC.Core.Coercion   (mkUnbranchedAxInstCo,mkSymCo,Role(..))++import Control.Applicative ( Alternative(..) )++import Control.Monad+import Data.Bits as Bits+import qualified Data.ByteString as BS+import Data.Int+import Data.Ratio+import Data.Word++{-+Note [Constant folding]+~~~~~~~~~~~~~~~~~~~~~~~+primOpRules generates a rewrite rule for each primop+These rules do what is often called "constant folding"+E.g. the rules for +# might say+        4 +# 5 = 9+Well, of course you'd need a lot of rules if you did it+like that, so we use a BuiltinRule instead, so that we+can match in any two literal values.  So the rule is really+more like+        (Lit x) +# (Lit y) = Lit (x+#y)+where the (+#) on the rhs is done at compile time++That is why these rules are built in here.+-}++primOpRules ::  Name -> PrimOp -> Maybe CoreRule+primOpRules nm = \case+   TagToEnumOp -> mkPrimOpRule nm 2 [ tagToEnumRule ]+   DataToTagOp -> mkPrimOpRule nm 2 [ dataToTagRule ]++   -- Int operations+   IntAddOp    -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (+))+                                    , identityPlatform zeroi+                                    , numFoldingRules IntAddOp intPrimOps+                                    ]+   IntSubOp    -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (-))+                                    , rightIdentityPlatform zeroi+                                    , equalArgs >> retLit zeroi+                                    , numFoldingRules IntSubOp intPrimOps+                                    ]+   IntAddCOp   -> mkPrimOpRule nm 2 [ binaryLit (intOpC2 (+))+                                    , identityCPlatform zeroi ]+   IntSubCOp   -> mkPrimOpRule nm 2 [ binaryLit (intOpC2 (-))+                                    , rightIdentityCPlatform zeroi+                                    , equalArgs >> retLitNoC zeroi ]+   IntMulOp    -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (*))+                                    , zeroElem zeroi+                                    , identityPlatform onei+                                    , numFoldingRules IntMulOp intPrimOps+                                    ]+   IntQuotOp   -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (intOp2 quot)+                                    , leftZero zeroi+                                    , rightIdentityPlatform onei+                                    , equalArgs >> retLit onei ]+   IntRemOp    -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (intOp2 rem)+                                    , leftZero zeroi+                                    , do l <- getLiteral 1+                                         platform <- getPlatform+                                         guard (l == onei platform)+                                         retLit zeroi+                                    , equalArgs >> retLit zeroi+                                    , equalArgs >> retLit zeroi ]+   AndIOp      -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (.&.))+                                    , idempotent+                                    , zeroElem zeroi ]+   OrIOp       -> mkPrimOpRule nm 2 [ binaryLit (intOp2 (.|.))+                                    , idempotent+                                    , identityPlatform zeroi ]+   XorIOp      -> mkPrimOpRule nm 2 [ binaryLit (intOp2 xor)+                                    , identityPlatform zeroi+                                    , equalArgs >> retLit zeroi ]+   NotIOp      -> mkPrimOpRule nm 1 [ unaryLit complementOp+                                    , inversePrimOp NotIOp ]+   IntNegOp    -> mkPrimOpRule nm 1 [ unaryLit negOp+                                    , inversePrimOp IntNegOp ]+   ISllOp      -> mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftL)+                                    , rightIdentityPlatform zeroi ]+   ISraOp      -> mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftR)+                                    , rightIdentityPlatform zeroi ]+   ISrlOp      -> mkPrimOpRule nm 2 [ shiftRule shiftRightLogical+                                    , rightIdentityPlatform zeroi ]++   -- Word operations+   WordAddOp   -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (+))+                                    , identityPlatform zerow+                                    , numFoldingRules WordAddOp wordPrimOps+                                    ]+   WordSubOp   -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (-))+                                    , rightIdentityPlatform zerow+                                    , equalArgs >> retLit zerow+                                    , numFoldingRules WordSubOp wordPrimOps+                                    ]+   WordAddCOp  -> mkPrimOpRule nm 2 [ binaryLit (wordOpC2 (+))+                                    , identityCPlatform zerow ]+   WordSubCOp  -> mkPrimOpRule nm 2 [ binaryLit (wordOpC2 (-))+                                    , rightIdentityCPlatform zerow+                                    , equalArgs >> retLitNoC zerow ]+   WordMulOp   -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (*))+                                    , identityPlatform onew+                                    , numFoldingRules WordMulOp wordPrimOps+                                    ]+   WordQuotOp  -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (wordOp2 quot)+                                    , rightIdentityPlatform onew ]+   WordRemOp   -> mkPrimOpRule nm 2 [ nonZeroLit 1 >> binaryLit (wordOp2 rem)+                                    , leftZero zerow+                                    , do l <- getLiteral 1+                                         platform <- getPlatform+                                         guard (l == onew platform)+                                         retLit zerow+                                    , equalArgs >> retLit zerow ]+   AndOp       -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (.&.))+                                    , idempotent+                                    , zeroElem zerow ]+   OrOp        -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 (.|.))+                                    , idempotent+                                    , identityPlatform zerow ]+   XorOp       -> mkPrimOpRule nm 2 [ binaryLit (wordOp2 xor)+                                    , identityPlatform zerow+                                    , equalArgs >> retLit zerow ]+   NotOp       -> mkPrimOpRule nm 1 [ unaryLit complementOp+                                    , inversePrimOp NotOp ]+   SllOp       -> mkPrimOpRule nm 2 [ shiftRule (const Bits.shiftL) ]+   SrlOp       -> mkPrimOpRule nm 2 [ shiftRule shiftRightLogical ]++   -- coercions+   Word2IntOp     -> mkPrimOpRule nm 1 [ liftLitPlatform word2IntLit+                                       , inversePrimOp Int2WordOp ]+   Int2WordOp     -> mkPrimOpRule nm 1 [ liftLitPlatform int2WordLit+                                       , inversePrimOp Word2IntOp ]+   Narrow8IntOp   -> mkPrimOpRule nm 1 [ liftLit narrow8IntLit+                                       , subsumedByPrimOp Narrow8IntOp+                                       , Narrow8IntOp `subsumesPrimOp` Narrow16IntOp+                                       , Narrow8IntOp `subsumesPrimOp` Narrow32IntOp+                                       , narrowSubsumesAnd AndIOp Narrow8IntOp 8 ]+   Narrow16IntOp  -> mkPrimOpRule nm 1 [ liftLit narrow16IntLit+                                       , subsumedByPrimOp Narrow8IntOp+                                       , subsumedByPrimOp Narrow16IntOp+                                       , Narrow16IntOp `subsumesPrimOp` Narrow32IntOp+                                       , narrowSubsumesAnd AndIOp Narrow16IntOp 16 ]+   Narrow32IntOp  -> mkPrimOpRule nm 1 [ liftLit narrow32IntLit+                                       , subsumedByPrimOp Narrow8IntOp+                                       , subsumedByPrimOp Narrow16IntOp+                                       , subsumedByPrimOp Narrow32IntOp+                                       , removeOp32+                                       , narrowSubsumesAnd AndIOp Narrow32IntOp 32 ]+   Narrow8WordOp  -> mkPrimOpRule nm 1 [ liftLit narrow8WordLit+                                       , subsumedByPrimOp Narrow8WordOp+                                       , Narrow8WordOp `subsumesPrimOp` Narrow16WordOp+                                       , Narrow8WordOp `subsumesPrimOp` Narrow32WordOp+                                       , narrowSubsumesAnd AndOp Narrow8WordOp 8 ]+   Narrow16WordOp -> mkPrimOpRule nm 1 [ liftLit narrow16WordLit+                                       , subsumedByPrimOp Narrow8WordOp+                                       , subsumedByPrimOp Narrow16WordOp+                                       , Narrow16WordOp `subsumesPrimOp` Narrow32WordOp+                                       , narrowSubsumesAnd AndOp Narrow16WordOp 16 ]+   Narrow32WordOp -> mkPrimOpRule nm 1 [ liftLit narrow32WordLit+                                       , subsumedByPrimOp Narrow8WordOp+                                       , subsumedByPrimOp Narrow16WordOp+                                       , subsumedByPrimOp Narrow32WordOp+                                       , removeOp32+                                       , narrowSubsumesAnd AndOp Narrow32WordOp 32 ]+   OrdOp          -> mkPrimOpRule nm 1 [ liftLit char2IntLit+                                       , inversePrimOp ChrOp ]+   ChrOp          -> mkPrimOpRule nm 1 [ do [Lit lit] <- getArgs+                                            guard (litFitsInChar lit)+                                            liftLit int2CharLit+                                       , inversePrimOp OrdOp ]+   Float2IntOp    -> mkPrimOpRule nm 1 [ liftLit float2IntLit ]+   Int2FloatOp    -> mkPrimOpRule nm 1 [ liftLit int2FloatLit ]+   Double2IntOp   -> mkPrimOpRule nm 1 [ liftLit double2IntLit ]+   Int2DoubleOp   -> mkPrimOpRule nm 1 [ liftLit int2DoubleLit ]+   -- SUP: Not sure what the standard says about precision in the following 2 cases+   Float2DoubleOp -> mkPrimOpRule nm 1 [ liftLit float2DoubleLit ]+   Double2FloatOp -> mkPrimOpRule nm 1 [ liftLit double2FloatLit ]++   -- Float+   FloatAddOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (+))+                                     , identity zerof ]+   FloatSubOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (-))+                                     , rightIdentity zerof ]+   FloatMulOp   -> mkPrimOpRule nm 2 [ binaryLit (floatOp2 (*))+                                     , identity onef+                                     , strengthReduction twof FloatAddOp  ]+             -- zeroElem zerof doesn't hold because of NaN+   FloatDivOp   -> mkPrimOpRule nm 2 [ guardFloatDiv >> binaryLit (floatOp2 (/))+                                     , rightIdentity onef ]+   FloatNegOp   -> mkPrimOpRule nm 1 [ unaryLit negOp+                                     , inversePrimOp FloatNegOp ]++   -- Double+   DoubleAddOp   -> mkPrimOpRule nm 2 [ binaryLit (doubleOp2 (+))+                                      , identity zerod ]+   DoubleSubOp   -> mkPrimOpRule nm 2 [ binaryLit (doubleOp2 (-))+                                      , rightIdentity zerod ]+   DoubleMulOp   -> mkPrimOpRule nm 2 [ binaryLit (doubleOp2 (*))+                                      , identity oned+                                      , strengthReduction twod DoubleAddOp  ]+              -- zeroElem zerod doesn't hold because of NaN+   DoubleDivOp   -> mkPrimOpRule nm 2 [ guardDoubleDiv >> binaryLit (doubleOp2 (/))+                                      , rightIdentity oned ]+   DoubleNegOp   -> mkPrimOpRule nm 1 [ unaryLit negOp+                                      , inversePrimOp DoubleNegOp ]++   -- Relational operators++   IntEqOp    -> mkRelOpRule nm (==) [ litEq True ]+   IntNeOp    -> mkRelOpRule nm (/=) [ litEq False ]+   CharEqOp   -> mkRelOpRule nm (==) [ litEq True ]+   CharNeOp   -> mkRelOpRule nm (/=) [ litEq False ]++   IntGtOp    -> mkRelOpRule nm (>)  [ boundsCmp Gt ]+   IntGeOp    -> mkRelOpRule nm (>=) [ boundsCmp Ge ]+   IntLeOp    -> mkRelOpRule nm (<=) [ boundsCmp Le ]+   IntLtOp    -> mkRelOpRule nm (<)  [ boundsCmp Lt ]++   CharGtOp   -> mkRelOpRule nm (>)  [ boundsCmp Gt ]+   CharGeOp   -> mkRelOpRule nm (>=) [ boundsCmp Ge ]+   CharLeOp   -> mkRelOpRule nm (<=) [ boundsCmp Le ]+   CharLtOp   -> mkRelOpRule nm (<)  [ boundsCmp Lt ]++   FloatGtOp  -> mkFloatingRelOpRule nm (>)+   FloatGeOp  -> mkFloatingRelOpRule nm (>=)+   FloatLeOp  -> mkFloatingRelOpRule nm (<=)+   FloatLtOp  -> mkFloatingRelOpRule nm (<)+   FloatEqOp  -> mkFloatingRelOpRule nm (==)+   FloatNeOp  -> mkFloatingRelOpRule nm (/=)++   DoubleGtOp -> mkFloatingRelOpRule nm (>)+   DoubleGeOp -> mkFloatingRelOpRule nm (>=)+   DoubleLeOp -> mkFloatingRelOpRule nm (<=)+   DoubleLtOp -> mkFloatingRelOpRule nm (<)+   DoubleEqOp -> mkFloatingRelOpRule nm (==)+   DoubleNeOp -> mkFloatingRelOpRule nm (/=)++   WordGtOp   -> mkRelOpRule nm (>)  [ boundsCmp Gt ]+   WordGeOp   -> mkRelOpRule nm (>=) [ boundsCmp Ge ]+   WordLeOp   -> mkRelOpRule nm (<=) [ boundsCmp Le ]+   WordLtOp   -> mkRelOpRule nm (<)  [ boundsCmp Lt ]+   WordEqOp   -> mkRelOpRule nm (==) [ litEq True ]+   WordNeOp   -> mkRelOpRule nm (/=) [ litEq False ]++   AddrAddOp  -> mkPrimOpRule nm 2 [ rightIdentityPlatform zeroi ]++   SeqOp      -> mkPrimOpRule nm 4 [ seqRule ]+   SparkOp    -> mkPrimOpRule nm 4 [ sparkRule ]++   _          -> Nothing++{-+************************************************************************+*                                                                      *+\subsection{Doing the business}+*                                                                      *+************************************************************************+-}++-- useful shorthands+mkPrimOpRule :: Name -> Int -> [RuleM CoreExpr] -> Maybe CoreRule+mkPrimOpRule nm arity rules = Just $ mkBasicRule nm arity (msum rules)++mkRelOpRule :: Name -> (forall a . Ord a => a -> a -> Bool)+            -> [RuleM CoreExpr] -> Maybe CoreRule+mkRelOpRule nm cmp extra+  = mkPrimOpRule nm 2 $+    binaryCmpLit cmp : equal_rule : extra+  where+        -- x `cmp` x does not depend on x, so+        -- compute it for the arbitrary value 'True'+        -- and use that result+    equal_rule = do { equalArgs+                    ; platform <- getPlatform+                    ; return (if cmp True True+                              then trueValInt  platform+                              else falseValInt platform) }++{- Note [Rules for floating-point comparisons]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We need different rules for floating-point values because for floats+it is not true that x = x (for NaNs); so we do not want the equal_rule+rule that mkRelOpRule uses.++Note also that, in the case of equality/inequality, we do /not/+want to switch to a case-expression.  For example, we do not want+to convert+   case (eqFloat# x 3.8#) of+     True -> this+     False -> that+to+  case x of+    3.8#::Float# -> this+    _            -> that+See #9238.  Reason: comparing floating-point values for equality+delicate, and we don't want to implement that delicacy in the code for+case expressions.  So we make it an invariant of Core that a case+expression never scrutinises a Float# or Double#.++This transformation is what the litEq rule does;+see Note [The litEq rule: converting equality to case].+So we /refrain/ from using litEq for mkFloatingRelOpRule.+-}++mkFloatingRelOpRule :: Name -> (forall a . Ord a => a -> a -> Bool)+                    -> Maybe CoreRule+-- See Note [Rules for floating-point comparisons]+mkFloatingRelOpRule nm cmp+  = mkPrimOpRule nm 2 [binaryCmpLit cmp]++-- common constants+zeroi, onei, zerow, onew :: Platform -> Literal+zeroi platform = mkLitInt  platform 0+onei  platform = mkLitInt  platform 1+zerow platform = mkLitWord platform 0+onew  platform = mkLitWord platform 1++zerof, onef, twof, zerod, oned, twod :: Literal+zerof = mkLitFloat 0.0+onef  = mkLitFloat 1.0+twof  = mkLitFloat 2.0+zerod = mkLitDouble 0.0+oned  = mkLitDouble 1.0+twod  = mkLitDouble 2.0++cmpOp :: Platform -> (forall a . Ord a => a -> a -> Bool)+      -> Literal -> Literal -> Maybe CoreExpr+cmpOp platform cmp = go+  where+    done True  = Just $ trueValInt  platform+    done False = Just $ falseValInt platform++    -- These compares are at different types+    go (LitChar i1)   (LitChar i2)   = done (i1 `cmp` i2)+    go (LitFloat i1)  (LitFloat i2)  = done (i1 `cmp` i2)+    go (LitDouble i1) (LitDouble i2) = done (i1 `cmp` i2)+    go (LitNumber nt1 i1 _) (LitNumber nt2 i2 _)+      | nt1 /= nt2 = Nothing+      | otherwise  = done (i1 `cmp` i2)+    go _               _               = Nothing++--------------------------++negOp :: RuleOpts -> Literal -> Maybe CoreExpr  -- Negate+negOp env = \case+   (LitFloat 0.0)  -> Nothing  -- can't represent -0.0 as a Rational+   (LitFloat f)    -> Just (mkFloatVal env (-f))+   (LitDouble 0.0) -> Nothing+   (LitDouble d)   -> Just (mkDoubleVal env (-d))+   (LitNumber nt i t)+      | litNumIsSigned nt -> Just (Lit (mkLitNumberWrap (roPlatform env) nt (-i) t))+   _ -> Nothing++complementOp :: RuleOpts -> Literal -> Maybe CoreExpr  -- Binary complement+complementOp env (LitNumber nt i t) =+   Just (Lit (mkLitNumberWrap (roPlatform env) nt (complement i) t))+complementOp _      _            = Nothing++--------------------------+intOp2 :: (Integral a, Integral b)+       => (a -> b -> Integer)+       -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr+intOp2 = intOp2' . const++intOp2' :: (Integral a, Integral b)+        => (RuleOpts -> a -> b -> Integer)+        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr+intOp2' op env (LitNumber LitNumInt i1 _) (LitNumber LitNumInt i2 _) =+  let o = op env+  in  intResult (roPlatform env) (fromInteger i1 `o` fromInteger i2)+intOp2' _  _      _            _            = Nothing  -- Could find LitLit++intOpC2 :: (Integral a, Integral b)+        => (a -> b -> Integer)+        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr+intOpC2 op env (LitNumber LitNumInt i1 _) (LitNumber LitNumInt i2 _) = do+  intCResult (roPlatform env) (fromInteger i1 `op` fromInteger i2)+intOpC2 _  _      _            _            = Nothing  -- Could find LitLit++shiftRightLogical :: Platform -> Integer -> Int -> Integer+-- Shift right, putting zeros in rather than sign-propagating as Bits.shiftR would do+-- Do this by converting to Word and back.  Obviously this won't work for big+-- values, but its ok as we use it here+shiftRightLogical platform x n =+    case platformWordSize platform of+      PW4 -> fromIntegral (fromInteger x `shiftR` n :: Word32)+      PW8 -> fromIntegral (fromInteger x `shiftR` n :: Word64)++--------------------------+retLit :: (Platform -> Literal) -> RuleM CoreExpr+retLit l = do platform <- getPlatform+              return $ Lit $ l platform++retLitNoC :: (Platform -> Literal) -> RuleM CoreExpr+retLitNoC l = do platform <- getPlatform+                 let lit = l platform+                 let ty = literalType lit+                 return $ mkCoreUbxTup [ty, ty] [Lit lit, Lit (zeroi platform)]++wordOp2 :: (Integral a, Integral b)+        => (a -> b -> Integer)+        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr+wordOp2 op env (LitNumber LitNumWord w1 _) (LitNumber LitNumWord w2 _)+    = wordResult (roPlatform env) (fromInteger w1 `op` fromInteger w2)+wordOp2 _ _ _ _ = Nothing  -- Could find LitLit++wordOpC2 :: (Integral a, Integral b)+        => (a -> b -> Integer)+        -> RuleOpts -> Literal -> Literal -> Maybe CoreExpr+wordOpC2 op env (LitNumber LitNumWord w1 _) (LitNumber LitNumWord w2 _) =+  wordCResult (roPlatform env) (fromInteger w1 `op` fromInteger w2)+wordOpC2 _ _ _ _ = Nothing  -- Could find LitLit++shiftRule :: (Platform -> Integer -> Int -> Integer) -> RuleM CoreExpr+-- Shifts take an Int; hence third arg of op is Int+-- Used for shift primops+--    ISllOp, ISraOp, ISrlOp :: Word# -> Int# -> Word#+--    SllOp, SrlOp           :: Word# -> Int# -> Word#+shiftRule shift_op+  = do { platform <- getPlatform+       ; [e1, Lit (LitNumber LitNumInt shift_len _)] <- getArgs+       ; case e1 of+           _ | shift_len == 0+             -> return e1+             -- See Note [Guarding against silly shifts]+             | shift_len < 0 || shift_len > toInteger (platformWordSizeInBits platform)+             -> return $ Lit $ mkLitNumberWrap platform LitNumInt 0 (exprType e1)++           -- Do the shift at type Integer, but shift length is Int+           Lit (LitNumber nt x t)+             | 0 < shift_len+             , shift_len <= toInteger (platformWordSizeInBits platform)+             -> let op = shift_op platform+                    y  = x `op` fromInteger shift_len+                in  liftMaybe $ Just (Lit (mkLitNumberWrap platform nt y t))++           _ -> mzero }++--------------------------+floatOp2 :: (Rational -> Rational -> Rational)+         -> RuleOpts -> Literal -> Literal+         -> Maybe (Expr CoreBndr)+floatOp2 op env (LitFloat f1) (LitFloat f2)+  = Just (mkFloatVal env (f1 `op` f2))+floatOp2 _ _ _ _ = Nothing++--------------------------+doubleOp2 :: (Rational -> Rational -> Rational)+          -> RuleOpts -> Literal -> Literal+          -> Maybe (Expr CoreBndr)+doubleOp2 op env (LitDouble f1) (LitDouble f2)+  = Just (mkDoubleVal env (f1 `op` f2))+doubleOp2 _ _ _ _ = Nothing++--------------------------+{- Note [The litEq rule: converting equality to case]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+This stuff turns+     n ==# 3#+into+     case n of+       3# -> True+       m  -> False++This is a Good Thing, because it allows case-of case things+to happen, and case-default absorption to happen.  For+example:++     if (n ==# 3#) || (n ==# 4#) then e1 else e2+will transform to+     case n of+       3# -> e1+       4# -> e1+       m  -> e2+(modulo the usual precautions to avoid duplicating e1)+-}++litEq :: Bool  -- True <=> equality, False <=> inequality+      -> RuleM CoreExpr+litEq is_eq = msum+  [ do [Lit lit, expr] <- getArgs+       platform <- getPlatform+       do_lit_eq platform lit expr+  , do [expr, Lit lit] <- getArgs+       platform <- getPlatform+       do_lit_eq platform lit expr ]+  where+    do_lit_eq platform lit expr = do+      guard (not (litIsLifted lit))+      return (mkWildCase expr (literalType lit) intPrimTy+                    [(DEFAULT,    [], val_if_neq),+                     (LitAlt lit, [], val_if_eq)])+      where+        val_if_eq  | is_eq     = trueValInt  platform+                   | otherwise = falseValInt platform+        val_if_neq | is_eq     = falseValInt platform+                   | otherwise = trueValInt  platform+++-- | Check if there is comparison with minBound or maxBound, that is+-- always true or false. For instance, an Int cannot be smaller than its+-- minBound, so we can replace such comparison with False.+boundsCmp :: Comparison -> RuleM CoreExpr+boundsCmp op = do+  platform <- getPlatform+  [a, b] <- getArgs+  liftMaybe $ mkRuleFn platform op a b++data Comparison = Gt | Ge | Lt | Le++mkRuleFn :: Platform -> Comparison -> CoreExpr -> CoreExpr -> Maybe CoreExpr+mkRuleFn platform Gt (Lit lit) _ | isMinBound platform lit = Just $ falseValInt platform+mkRuleFn platform Le (Lit lit) _ | isMinBound platform lit = Just $ trueValInt  platform+mkRuleFn platform Ge _ (Lit lit) | isMinBound platform lit = Just $ trueValInt  platform+mkRuleFn platform Lt _ (Lit lit) | isMinBound platform lit = Just $ falseValInt platform+mkRuleFn platform Ge (Lit lit) _ | isMaxBound platform lit = Just $ trueValInt  platform+mkRuleFn platform Lt (Lit lit) _ | isMaxBound platform lit = Just $ falseValInt platform+mkRuleFn platform Gt _ (Lit lit) | isMaxBound platform lit = Just $ falseValInt platform+mkRuleFn platform Le _ (Lit lit) | isMaxBound platform lit = Just $ trueValInt  platform+mkRuleFn _ _ _ _                                           = Nothing++isMinBound :: Platform -> Literal -> Bool+isMinBound _        (LitChar c)        = c == minBound+isMinBound platform (LitNumber nt i _) = case nt of+   LitNumInt     -> i == platformMinInt platform+   LitNumInt64   -> i == toInteger (minBound :: Int64)+   LitNumWord    -> i == 0+   LitNumWord64  -> i == 0+   LitNumNatural -> i == 0+   LitNumInteger -> False+isMinBound _        _                  = False++isMaxBound :: Platform -> Literal -> Bool+isMaxBound _        (LitChar c)        = c == maxBound+isMaxBound platform (LitNumber nt i _) = case nt of+   LitNumInt     -> i == platformMaxInt platform+   LitNumInt64   -> i == toInteger (maxBound :: Int64)+   LitNumWord    -> i == platformMaxWord platform+   LitNumWord64  -> i == toInteger (maxBound :: Word64)+   LitNumNatural -> False+   LitNumInteger -> False+isMaxBound _        _                  = False++-- | Create an Int literal expression while ensuring the given Integer is in the+-- target Int range+intResult :: Platform -> Integer -> Maybe CoreExpr+intResult platform result = Just (intResult' platform result)++intResult' :: Platform -> Integer -> CoreExpr+intResult' platform result = Lit (mkLitIntWrap platform result)++-- | Create an unboxed pair of an Int literal expression, ensuring the given+-- Integer is in the target Int range and the corresponding overflow flag+-- (@0#@/@1#@) if it wasn't.+intCResult :: Platform -> Integer -> Maybe CoreExpr+intCResult platform result = Just (mkPair [Lit lit, Lit c])+  where+    mkPair = mkCoreUbxTup [intPrimTy, intPrimTy]+    (lit, b) = mkLitIntWrapC platform result+    c = if b then onei platform else zeroi platform++-- | Create a Word literal expression while ensuring the given Integer is in the+-- target Word range+wordResult :: Platform -> Integer -> Maybe CoreExpr+wordResult platform result = Just (wordResult' platform result)++wordResult' :: Platform -> Integer -> CoreExpr+wordResult' platform result = Lit (mkLitWordWrap platform result)++-- | Create an unboxed pair of a Word literal expression, ensuring the given+-- Integer is in the target Word range and the corresponding carry flag+-- (@0#@/@1#@) if it wasn't.+wordCResult :: Platform -> Integer -> Maybe CoreExpr+wordCResult platform result = Just (mkPair [Lit lit, Lit c])+  where+    mkPair = mkCoreUbxTup [wordPrimTy, intPrimTy]+    (lit, b) = mkLitWordWrapC platform result+    c = if b then onei platform else zeroi platform++inversePrimOp :: PrimOp -> RuleM CoreExpr+inversePrimOp primop = do+  [Var primop_id `App` e] <- getArgs+  matchPrimOpId primop primop_id+  return e++subsumesPrimOp :: PrimOp -> PrimOp -> RuleM CoreExpr+this `subsumesPrimOp` that = do+  [Var primop_id `App` e] <- getArgs+  matchPrimOpId that primop_id+  return (Var (mkPrimOpId this) `App` e)++subsumedByPrimOp :: PrimOp -> RuleM CoreExpr+subsumedByPrimOp primop = do+  [e@(Var primop_id `App` _)] <- getArgs+  matchPrimOpId primop primop_id+  return e++-- | narrow subsumes bitwise `and` with full mask (cf #16402):+--+--       narrowN (x .&. m)+--       m .&. (2^N-1) = 2^N-1+--       ==> narrowN x+--+-- e.g.  narrow16 (x .&. 0xFFFF)+--       ==> narrow16 x+--+narrowSubsumesAnd :: PrimOp -> PrimOp -> Int -> RuleM CoreExpr+narrowSubsumesAnd and_primop narrw n = do+  [Var primop_id `App` x `App` y] <- getArgs+  matchPrimOpId and_primop primop_id+  let mask = bit n -1+      g v (Lit (LitNumber _ m _)) = do+         guard (m .&. mask == mask)+         return (Var (mkPrimOpId narrw) `App` v)+      g _ _ = mzero+  g x y <|> g y x++idempotent :: RuleM CoreExpr+idempotent = do [e1, e2] <- getArgs+                guard $ cheapEqExpr e1 e2+                return e1++{-+Note [Guarding against silly shifts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this code:++  import Data.Bits( (.|.), shiftL )+  chunkToBitmap :: [Bool] -> Word32+  chunkToBitmap chunk = foldr (.|.) 0 [ 1 `shiftL` n | (True,n) <- zip chunk [0..] ]++This optimises to:+Shift.$wgo = \ (w_sCS :: GHC.Prim.Int#) (w1_sCT :: [GHC.Types.Bool]) ->+    case w1_sCT of _ {+      [] -> 0##;+      : x_aAW xs_aAX ->+        case x_aAW of _ {+          GHC.Types.False ->+            case w_sCS of wild2_Xh {+              __DEFAULT -> Shift.$wgo (GHC.Prim.+# wild2_Xh 1) xs_aAX;+              9223372036854775807 -> 0## };+          GHC.Types.True ->+            case GHC.Prim.>=# w_sCS 64 of _ {+              GHC.Types.False ->+                case w_sCS of wild3_Xh {+                  __DEFAULT ->+                    case Shift.$wgo (GHC.Prim.+# wild3_Xh 1) xs_aAX of ww_sCW { __DEFAULT ->+                      GHC.Prim.or# (GHC.Prim.narrow32Word#+                                      (GHC.Prim.uncheckedShiftL# 1## wild3_Xh))+                                   ww_sCW+                     };+                  9223372036854775807 ->+                    GHC.Prim.narrow32Word#+!!!!-->                  (GHC.Prim.uncheckedShiftL# 1## 9223372036854775807)+                };+              GHC.Types.True ->+                case w_sCS of wild3_Xh {+                  __DEFAULT -> Shift.$wgo (GHC.Prim.+# wild3_Xh 1) xs_aAX;+                  9223372036854775807 -> 0##+                } } } }++Note the massive shift on line "!!!!".  It can't happen, because we've checked+that w < 64, but the optimiser didn't spot that. We DO NOT want to constant-fold this!+Moreover, if the programmer writes (n `uncheckedShiftL` 9223372036854775807), we+can't constant fold it, but if it gets to the assembler we get+     Error: operand type mismatch for `shl'++So the best thing to do is to rewrite the shift with a call to error,+when the second arg is large. However, in general we cannot do this; consider+this case++    let x = I# (uncheckedIShiftL# n 80)+    in ...++Here x contains an invalid shift and consequently we would like to rewrite it+as follows:++    let x = I# (error "invalid shift)+    in ...++This was originally done in the fix to #16449 but this breaks the let/app+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.++Consequently we instead take advantage of the fact that large shifts are+undefined behavior (see associated documentation in primops.txt.pp) and+transform the invalid shift into an "obviously incorrect" value.++There are two cases:++- Shifting fixed-width things: the primops ISll, Sll, etc+  These are handled by shiftRule.++  We are happy to shift by any amount up to wordSize but no more.++- Shifting Integers: the function shiftLInteger, shiftRInteger+  from the 'integer' library.   These are handled by rule_shift_op,+  and match_Integer_shift_op.++  Here we could in principle shift by any amount, but we arbitrary+  limit the shift to 4 bits; in particular we do not want shift by a+  huge amount, which can happen in code like that above.++The two cases are more different in their code paths that is comfortable,+but that is only a historical accident.+++************************************************************************+*                                                                      *+\subsection{Vaguely generic functions}+*                                                                      *+************************************************************************+-}++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,+                  ru_nargs = n_args,+                  ru_try   = runRuleM rm }++newtype RuleM r = RuleM+  { runRuleM :: RuleOpts -> InScopeEnv -> Id -> [CoreExpr] -> Maybe r }+  deriving (Functor)++instance Applicative RuleM where+    pure x = RuleM $ \_ _ _ _ -> Just x+    (<*>) = ap++instance Monad RuleM where+  RuleM f >>= g+    = RuleM $ \env iu fn args ->+              case f env iu fn args of+                Nothing -> Nothing+                Just r  -> runRuleM (g r) env iu fn args++instance MonadFail RuleM where+    fail _ = mzero++instance Alternative RuleM where+  empty = RuleM $ \_ _ _ _ -> Nothing+  RuleM f1 <|> RuleM f2 = RuleM $ \env iu fn args ->+    f1 env iu fn args <|> f2 env iu fn args++instance MonadPlus RuleM++getPlatform :: RuleM Platform+getPlatform = roPlatform <$> getEnv++getEnv :: RuleM RuleOpts+getEnv = RuleM $ \env _ _ _ -> Just env++liftMaybe :: Maybe a -> RuleM a+liftMaybe Nothing = mzero+liftMaybe (Just x) = return x++liftLit :: (Literal -> Literal) -> RuleM CoreExpr+liftLit f = liftLitPlatform (const f)++liftLitPlatform :: (Platform -> Literal -> Literal) -> RuleM CoreExpr+liftLitPlatform f = do+  platform <- getPlatform+  [Lit lit] <- getArgs+  return $ Lit (f platform lit)++removeOp32 :: RuleM CoreExpr+removeOp32 = do+  platform <- getPlatform+  case platformWordSize platform of+    PW4 -> do+      [e] <- getArgs+      return e+    PW8 ->+      mzero++getArgs :: RuleM [CoreExpr]+getArgs = RuleM $ \_ _ _ args -> Just args++getInScopeEnv :: RuleM InScopeEnv+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+  (Lit l:_) -> Just l+  _ -> Nothing++unaryLit :: (RuleOpts -> Literal -> Maybe CoreExpr) -> RuleM CoreExpr+unaryLit op = do+  env <- getEnv+  [Lit l] <- getArgs+  liftMaybe $ op env (convFloating env l)++binaryLit :: (RuleOpts -> Literal -> Literal -> Maybe CoreExpr) -> RuleM CoreExpr+binaryLit op = do+  env <- getEnv+  [Lit l1, Lit l2] <- getArgs+  liftMaybe $ op env (convFloating env l1) (convFloating env l2)++binaryCmpLit :: (forall a . Ord a => a -> a -> Bool) -> RuleM CoreExpr+binaryCmpLit op = do+  platform <- getPlatform+  binaryLit (\_ -> cmpOp platform op)++leftIdentity :: Literal -> RuleM CoreExpr+leftIdentity id_lit = leftIdentityPlatform (const id_lit)++rightIdentity :: Literal -> RuleM CoreExpr+rightIdentity id_lit = rightIdentityPlatform (const id_lit)++identity :: Literal -> RuleM CoreExpr+identity lit = leftIdentity lit `mplus` rightIdentity lit++leftIdentityPlatform :: (Platform -> Literal) -> RuleM CoreExpr+leftIdentityPlatform id_lit = do+  platform <- getPlatform+  [Lit l1, e2] <- getArgs+  guard $ l1 == id_lit platform+  return e2++-- | Left identity rule for PrimOps like 'IntAddC' and 'WordAddC', where, in+-- addition to the result, we have to indicate that no carry/overflow occurred.+leftIdentityCPlatform :: (Platform -> Literal) -> RuleM CoreExpr+leftIdentityCPlatform id_lit = do+  platform <- getPlatform+  [Lit l1, e2] <- getArgs+  guard $ l1 == id_lit platform+  let no_c = Lit (zeroi platform)+  return (mkCoreUbxTup [exprType e2, intPrimTy] [e2, no_c])++rightIdentityPlatform :: (Platform -> Literal) -> RuleM CoreExpr+rightIdentityPlatform id_lit = do+  platform <- getPlatform+  [e1, Lit l2] <- getArgs+  guard $ l2 == id_lit platform+  return e1++-- | Right identity rule for PrimOps like 'IntSubC' and 'WordSubC', where, in+-- addition to the result, we have to indicate that no carry/overflow occurred.+rightIdentityCPlatform :: (Platform -> Literal) -> RuleM CoreExpr+rightIdentityCPlatform id_lit = do+  platform <- getPlatform+  [e1, Lit l2] <- getArgs+  guard $ l2 == id_lit platform+  let no_c = Lit (zeroi platform)+  return (mkCoreUbxTup [exprType e1, intPrimTy] [e1, no_c])++identityPlatform :: (Platform -> Literal) -> RuleM CoreExpr+identityPlatform lit =+  leftIdentityPlatform lit `mplus` rightIdentityPlatform lit++-- | Identity rule for PrimOps like 'IntAddC' and 'WordAddC', where, in addition+-- to the result, we have to indicate that no carry/overflow occurred.+identityCPlatform :: (Platform -> Literal) -> RuleM CoreExpr+identityCPlatform lit =+  leftIdentityCPlatform lit `mplus` rightIdentityCPlatform lit++leftZero :: (Platform -> Literal) -> RuleM CoreExpr+leftZero zero = do+  platform <- getPlatform+  [Lit l1, _] <- getArgs+  guard $ l1 == zero platform+  return $ Lit l1++rightZero :: (Platform -> Literal) -> RuleM CoreExpr+rightZero zero = do+  platform <- getPlatform+  [_, Lit l2] <- getArgs+  guard $ l2 == zero platform+  return $ Lit l2++zeroElem :: (Platform -> Literal) -> RuleM CoreExpr+zeroElem lit = leftZero lit `mplus` rightZero lit++equalArgs :: RuleM ()+equalArgs = do+  [e1, e2] <- getArgs+  guard $ e1 `cheapEqExpr` e2++nonZeroLit :: Int -> RuleM ()+nonZeroLit n = getLiteral n >>= guard . not . isZeroLit++-- When excess precision is not requested, cut down the precision of the+-- Rational value to that of Float/Double. We confuse host architecture+-- and target architecture here, but it's convenient (and wrong :-).+convFloating :: RuleOpts -> Literal -> Literal+convFloating env (LitFloat  f) | not (roExcessRationalPrecision env) =+   LitFloat  (toRational (fromRational f :: Float ))+convFloating env (LitDouble d) | not (roExcessRationalPrecision env) =+   LitDouble (toRational (fromRational d :: Double))+convFloating _ l = l++guardFloatDiv :: RuleM ()+guardFloatDiv = do+  [Lit (LitFloat f1), Lit (LitFloat f2)] <- getArgs+  guard $ (f1 /=0 || f2 > 0) -- see Note [negative zero]+       && f2 /= 0            -- avoid NaN and Infinity/-Infinity++guardDoubleDiv :: RuleM ()+guardDoubleDiv = do+  [Lit (LitDouble d1), Lit (LitDouble d2)] <- getArgs+  guard $ (d1 /=0 || d2 > 0) -- see Note [negative zero]+       && d2 /= 0            -- avoid NaN and Infinity/-Infinity+-- Note [negative zero] Avoid (0 / -d), otherwise 0/(-1) reduces to+-- zero, but we might want to preserve the negative zero here which+-- is representable in Float/Double but not in (normalised)+-- Rational. (#3676) Perhaps we should generate (0 :% (-1)) instead?++strengthReduction :: Literal -> PrimOp -> RuleM CoreExpr+strengthReduction two_lit add_op = do -- Note [Strength reduction]+  arg <- msum [ do [arg, Lit mult_lit] <- getArgs+                   guard (mult_lit == two_lit)+                   return arg+              , do [Lit mult_lit, arg] <- getArgs+                   guard (mult_lit == two_lit)+                   return arg ]+  return $ Var (mkPrimOpId add_op) `App` arg `App` arg++-- Note [Strength reduction]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- This rule turns floating point multiplications of the form 2.0 * x and+-- x * 2.0 into x + x addition, because addition costs less than multiplication.+-- See #7116++-- Note [What's true and false]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- trueValInt and falseValInt represent true and false values returned by+-- comparison primops for Char, Int, Word, Integer, Double, Float and Addr.+-- True is represented as an unboxed 1# literal, while false is represented+-- as 0# literal.+-- We still need Bool data constructors (True and False) to use in a rule+-- for constant folding of equal Strings++trueValInt, falseValInt :: Platform -> Expr CoreBndr+trueValInt  platform = Lit $ onei  platform -- see Note [What's true and false]+falseValInt platform = Lit $ zeroi platform++trueValBool, falseValBool :: Expr CoreBndr+trueValBool   = Var trueDataConId -- see Note [What's true and false]+falseValBool  = Var falseDataConId++ltVal, eqVal, gtVal :: Expr CoreBndr+ltVal = Var ordLTDataConId+eqVal = Var ordEQDataConId+gtVal = Var ordGTDataConId++mkIntVal :: Platform -> Integer -> Expr CoreBndr+mkIntVal platform i = Lit (mkLitInt platform i)+mkFloatVal :: RuleOpts -> Rational -> Expr CoreBndr+mkFloatVal env f = Lit (convFloating env (LitFloat  f))+mkDoubleVal :: RuleOpts -> Rational -> Expr CoreBndr+mkDoubleVal env d = Lit (convFloating env (LitDouble d))++matchPrimOpId :: PrimOp -> Id -> RuleM ()+matchPrimOpId op id = do+  op' <- liftMaybe $ isPrimOpId_maybe id+  guard $ op == op'++{-+************************************************************************+*                                                                      *+\subsection{Special rules for seq, tagToEnum, dataToTag}+*                                                                      *+************************************************************************++Note [tagToEnum#]+~~~~~~~~~~~~~~~~~+Nasty check to ensure that tagToEnum# is applied to a type that is an+enumeration TyCon.  Unification may refine the type later, but this+check won't see that, alas.  It's crude but it works.++Here's are two cases that should fail+        f :: forall a. a+        f = tagToEnum# 0        -- Can't do tagToEnum# at a type variable++        g :: Int+        g = tagToEnum# 0        -- Int is not an enumeration++We used to make this check in the type inference engine, but it's quite+ugly to do so, because the delayed constraint solving means that we don't+really know what's going on until the end. It's very much a corner case+because we don't expect the user to call tagToEnum# at all; we merely+generate calls in derived instances of Enum.  So we compromise: a+rewrite rule rewrites a bad instance of tagToEnum# to an error call,+and emits a warning.+-}++tagToEnumRule :: RuleM CoreExpr+-- If     data T a = A | B | C+-- then   tagToEnum# (T ty) 2# -->  B ty+tagToEnumRule = do+  [Type ty, Lit (LitNumber LitNumInt i _)] <- getArgs+  case splitTyConApp_maybe ty of+    Just (tycon, tc_args) | isEnumerationTyCon tycon -> do+      let tag = fromInteger i+          correct_tag dc = (dataConTagZ dc) == tag+      (dc:rest) <- return $ filter correct_tag (tyConDataCons_maybe tycon `orElse` [])+      ASSERT(null rest) return ()+      return $ mkTyApps (Var (dataConWorkId dc)) tc_args++    -- See Note [tagToEnum#]+    _ -> WARN( True, text "tagToEnum# on non-enumeration type" <+> ppr ty )+         return $ mkRuntimeErrorApp rUNTIME_ERROR_ID ty "tagToEnum# on non-enumeration type"++------------------------------+dataToTagRule :: RuleM CoreExpr+-- See Note [dataToTag#] in primops.txt.pp+dataToTagRule = a `mplus` b+  where+    -- dataToTag (tagToEnum x)   ==>   x+    a = do+      [Type ty1, Var tag_to_enum `App` Type ty2 `App` tag] <- getArgs+      guard $ tag_to_enum `hasKey` tagToEnumKey+      guard $ ty1 `eqType` ty2+      return tag++    -- dataToTag (K e1 e2)  ==>   tag-of K+    -- This also works (via exprIsConApp_maybe) for+    --   dataToTag x+    -- where x's unfolding is a constructor application+    b = do+      dflags <- getPlatform+      [_, val_arg] <- getArgs+      in_scope <- getInScopeEnv+      (_,floats, dc,_,_) <- liftMaybe $ exprIsConApp_maybe in_scope val_arg+      ASSERT( not (isNewTyCon (dataConTyCon dc)) ) return ()+      return $ wrapFloats floats (mkIntVal dflags (toInteger (dataConTagZ dc)))++{- Note [dataToTag# magic]+~~~~~~~~~~~~~~~~~~~~~~~~~~+The primop dataToTag# is unusual because it evaluates its argument.+Only `SeqOp` shares that property.  (Other primops do not do anything+as fancy as argument evaluation.)  The special handling for dataToTag#+is:++* 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 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+  the returned value.++* An application like (dataToTag# (Just x)) is optimised by+  dataToTagRule in GHC.Core.Opt.ConstantFold.++* A case expression like+     case (dataToTag# e) of <alts>+  gets transformed t+     case e of <transformed alts>+  by GHC.Core.Opt.ConstantFold.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]) }+++{- *********************************************************************+*                                                                      *+             Rules for seq# and spark#+*                                                                      *+********************************************************************* -}++{- Note [seq# magic]+~~~~~~~~~~~~~~~~~~~~+The primop+   seq# :: forall a s . a -> State# s -> (# State# s, a #)++is /not/ the same as the Prelude function seq :: a -> b -> b+as you can see from its type.  In fact, seq# is the implementation+mechanism for 'evaluate'++   evaluate :: a -> IO a+   evaluate a = IO $ \s -> seq# a s++The semantics of seq# is+  * evaluate its first argument+  * and return it++Things to note++* Why do we need a primop at all?  That is, instead of+      case seq# x s of (# x, s #) -> blah+  why not instead say this?+      case x of { DEFAULT -> blah)++  Reason (see #5129): if we saw+    catch# (\s -> case x of { DEFAULT -> raiseIO# exn s }) handler++  then we'd drop the 'case x' because the body of the case is bottom+  anyway. But we don't want to do that; the whole /point/ of+  seq#/evaluate is to evaluate 'x' first in the IO monad.++  In short, we /always/ evaluate the first argument and never+  just discard it.++* Why return the value?  So that we can control sharing of seq'd+  values: in+     let x = e in x `seq` ... x ...+  We don't want to inline x, so better to represent it as+       let x = e in case seq# x RW of (# _, x' #) -> ... x' ...+  also it matches the type of rseq in the Eval monad.++Implementing seq#.  The compiler has magic for SeqOp in++- GHC.Core.Opt.ConstantFold.seqRule: eliminate (seq# <whnf> s)++- GHC.StgToCmm.Expr.cgExpr, and cgCase: special case for seq#++- 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]+  in GHC.Core.Opt.Simplify+-}++seqRule :: RuleM CoreExpr+seqRule = do+  [Type ty_a, Type _ty_s, a, s] <- getArgs+  guard $ exprIsHNF a+  return $ mkCoreUbxTup [exprType s, ty_a] [s, a]++-- spark# :: forall a s . a -> State# s -> (# State# s, a #)+sparkRule :: RuleM CoreExpr+sparkRule = seqRule -- reduce on HNF, just the same+  -- XXX perhaps we shouldn't do this, because a spark eliminated by+  -- this rule won't be counted as a dud at runtime?++{-+************************************************************************+*                                                                      *+\subsection{Built in rules}+*                                                                      *+************************************************************************++Note [Scoping for Builtin rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When compiling a (base-package) module that defines one of the+functions mentioned in the RHS of a built-in rule, there's a danger+that we'll see++        f = ...(eq String x)....++        ....and lower down...++        eqString = ...++Then a rewrite would give++        f = ...(eqString x)...+        ....and lower down...+        eqString = ...++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]+-- Rules for non-primops that can't be expressed using a RULE pragma+builtinRules+  = [BuiltinRule { ru_name = fsLit "AppendLitString",+                   ru_fn = unpackCStringFoldrName,+                   ru_nargs = 4, ru_try = match_append_lit },+     BuiltinRule { ru_name = fsLit "EqString", ru_fn = eqStringName,+                   ru_nargs = 2, ru_try = match_eq_string },+     BuiltinRule { ru_name = fsLit "Inline", ru_fn = inlineIdName,+                   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+        , do+          [arg, Lit (LitNumber LitNumInt d _)] <- getArgs+          Just n <- return $ exactLog2 d+          platform <- getPlatform+          return $ Var (mkPrimOpId ISraOp) `App` arg `App` mkIntVal platform n+        ],++     mkBasicRule modIntName 2 $ msum+        [ nonZeroLit 1 >> binaryLit (intOp2 mod)+        , leftZero zeroi+        , do+          [arg, Lit (LitNumber LitNumInt d _)] <- getArgs+          Just _ <- return $ exactLog2 d+          platform <- getPlatform+          return $ Var (mkPrimOpId AndIOp)+            `App` arg `App` mkIntVal platform (d - 1)+        ]+     ]+ ++ builtinIntegerRules+ ++ builtinNaturalRules+{-# NOINLINE builtinRules #-}+-- there is no benefit to inlining these yet, despite this, GHC produces+-- unfoldings for this regardless since the floated list entries look small.++builtinIntegerRules :: [CoreRule]+builtinIntegerRules =+ [rule_IntToInteger   "smallInteger"        smallIntegerName,+  rule_WordToInteger  "wordToInteger"       wordToIntegerName,+  rule_Int64ToInteger  "int64ToInteger"     int64ToIntegerName,+  rule_Word64ToInteger "word64ToInteger"    word64ToIntegerName,+  rule_convert        "integerToWord"       integerToWordName       mkWordLitWord,+  rule_convert        "integerToInt"        integerToIntName        mkIntLitInt,+  rule_convert        "integerToWord64"     integerToWord64Name     (\_ -> mkWord64LitWord64),+  rule_convert        "integerToInt64"      integerToInt64Name      (\_ -> mkInt64LitInt64),+  rule_binop          "plusInteger"         plusIntegerName         (+),+  rule_binop          "minusInteger"        minusIntegerName        (-),+  rule_binop          "timesInteger"        timesIntegerName        (*),+  rule_unop           "negateInteger"       negateIntegerName       negate,+  rule_binop_Prim     "eqInteger#"          eqIntegerPrimName       (==),+  rule_binop_Prim     "neqInteger#"         neqIntegerPrimName      (/=),+  rule_unop           "absInteger"          absIntegerName          abs,+  rule_unop           "signumInteger"       signumIntegerName       signum,+  rule_binop_Prim     "leInteger#"          leIntegerPrimName       (<=),+  rule_binop_Prim     "gtInteger#"          gtIntegerPrimName       (>),+  rule_binop_Prim     "ltInteger#"          ltIntegerPrimName       (<),+  rule_binop_Prim     "geInteger#"          geIntegerPrimName       (>=),+  rule_binop_Ordering "compareInteger"      compareIntegerName      compare,+  rule_encodeFloat    "encodeFloatInteger"  encodeFloatIntegerName  mkFloatLitFloat,+  rule_convert        "floatFromInteger"    floatFromIntegerName    (\_ -> mkFloatLitFloat),+  rule_encodeFloat    "encodeDoubleInteger" encodeDoubleIntegerName mkDoubleLitDouble,+  rule_decodeDouble   "decodeDoubleInteger" decodeDoubleIntegerName,+  rule_convert        "doubleFromInteger"   doubleFromIntegerName   (\_ -> mkDoubleLitDouble),+  rule_rationalTo     "rationalToFloat"     rationalToFloatName     mkFloatExpr,+  rule_rationalTo     "rationalToDouble"    rationalToDoubleName    mkDoubleExpr,+  rule_binop          "gcdInteger"          gcdIntegerName          gcd,+  rule_binop          "lcmInteger"          lcmIntegerName          lcm,+  rule_binop          "andInteger"          andIntegerName          (.&.),+  rule_binop          "orInteger"           orIntegerName           (.|.),+  rule_binop          "xorInteger"          xorIntegerName          xor,+  rule_unop           "complementInteger"   complementIntegerName   complement,+  rule_shift_op       "shiftLInteger"       shiftLIntegerName       shiftL,+  rule_shift_op       "shiftRInteger"       shiftRIntegerName       shiftR,+  rule_bitInteger     "bitInteger"          bitIntegerName,+  -- See Note [Integer division constant folding] in libraries/base/GHC/Real.hs+  rule_divop_one      "quotInteger"         quotIntegerName         quot,+  rule_divop_one      "remInteger"          remIntegerName          rem,+  rule_divop_one      "divInteger"          divIntegerName          div,+  rule_divop_one      "modInteger"          modIntegerName          mod,+  rule_divop_both     "divModInteger"       divModIntegerName       divMod,+  rule_divop_both     "quotRemInteger"      quotRemIntegerName      quotRem,+  -- These rules below don't actually have to be built in, but if we+  -- put them in the Haskell source then we'd have to duplicate them+  -- between all Integer implementations+  rule_XToIntegerToX "smallIntegerToInt"       integerToIntName    smallIntegerName,+  rule_XToIntegerToX "wordToIntegerToWord"     integerToWordName   wordToIntegerName,+  rule_XToIntegerToX "int64ToIntegerToInt64"   integerToInt64Name  int64ToIntegerName,+  rule_XToIntegerToX "word64ToIntegerToWord64" integerToWord64Name word64ToIntegerName,+  rule_smallIntegerTo "smallIntegerToWord"   integerToWordName     Int2WordOp,+  rule_smallIntegerTo "smallIntegerToFloat"  floatFromIntegerName  Int2FloatOp,+  rule_smallIntegerTo "smallIntegerToDouble" doubleFromIntegerName Int2DoubleOp+  ]+    where rule_convert str name convert+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_Integer_convert convert }+          rule_IntToInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_IntToInteger }+          rule_WordToInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_WordToInteger }+          rule_Int64ToInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_Int64ToInteger }+          rule_Word64ToInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_Word64ToInteger }+          rule_unop str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_Integer_unop op }+          rule_bitInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_bitInteger }+          rule_binop str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_binop op }+          rule_divop_both str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_divop_both op }+          rule_divop_one str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_divop_one op }+          rule_shift_op str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_shift_op op }+          rule_binop_Prim str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_binop_Prim op }+          rule_binop_Ordering str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_binop_Ordering op }+          rule_encodeFloat str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Integer_Int_encodeFloat op }+          rule_decodeDouble str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_decodeDouble }+          rule_XToIntegerToX str name toIntegerName+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_XToIntegerToX toIntegerName }+          rule_smallIntegerTo str name primOp+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_smallIntegerTo primOp }+          rule_rationalTo str name mkLit+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_rationalTo mkLit }++builtinNaturalRules :: [CoreRule]+builtinNaturalRules =+ [rule_binop              "plusNatural"        plusNaturalName         (+)+ ,rule_partial_binop      "minusNatural"       minusNaturalName        (\a b -> if a >= b then Just (a - b) else Nothing)+ ,rule_binop              "timesNatural"       timesNaturalName        (*)+ ,rule_NaturalFromInteger "naturalFromInteger" naturalFromIntegerName+ ,rule_NaturalToInteger   "naturalToInteger"   naturalToIntegerName+ ,rule_WordToNatural      "wordToNatural"      wordToNaturalName+ ]+    where rule_binop str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Natural_binop op }+          rule_partial_binop str name op+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 2,+                           ru_try = match_Natural_partial_binop op }+          rule_NaturalToInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_NaturalToInteger }+          rule_NaturalFromInteger str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_NaturalFromInteger }+          rule_WordToNatural str name+           = BuiltinRule { ru_name = fsLit str, ru_fn = name, ru_nargs = 1,+                           ru_try = match_WordToNatural }++---------------------------------------------------+-- The rule is this:+--      unpackFoldrCString# "foo" c (unpackFoldrCString# "baz" c n)+--      =  unpackFoldrCString# "foobaz" c n++match_append_lit :: RuleFun+match_append_lit _ id_unf _+        [ Type ty1+        , lit1+        , c1+        , e2+        ]+  -- N.B. Ensure that we strip off any ticks (e.g. source notes) from the+  -- `lit` and `c` arguments, lest this may fail to fire when building with+  -- -g3. See #16740.+  | (strTicks, Var unpk `App` Type ty2+                        `App` lit2+                        `App` c2+                        `App` n) <- stripTicksTop tickishFloatable e2+  , unpk `hasKey` unpackCStringFoldrIdKey+  , cheapEqExpr' tickishFloatable c1 c2+  , (c1Ticks, c1') <- stripTicksTop tickishFloatable c1+  , c2Ticks <- stripTicksTopT tickishFloatable c2+  , Just (LitString s1) <- exprIsLiteral_maybe id_unf lit1+  , Just (LitString s2) <- exprIsLiteral_maybe id_unf lit2+  = ASSERT( ty1 `eqType` ty2 )+    Just $ mkTicks strTicks+         $ Var unpk `App` Type ty1+                    `App` Lit (LitString (s1 `BS.append` s2))+                    `App` mkTicks (c1Ticks ++ c2Ticks) c1'+                    `App` n++match_append_lit _ _ _ _ = Nothing++---------------------------------------------------+-- The rule is this:+--      eqString (unpackCString# (Lit s1)) (unpackCString# (Lit s2)) = s1==s2++match_eq_string :: RuleFun+match_eq_string _ id_unf _+        [Var unpk1 `App` lit1, Var unpk2 `App` lit2]+  | unpk1 `hasKey` unpackCStringIdKey+  , unpk2 `hasKey` unpackCStringIdKey+  , Just (LitString s1) <- exprIsLiteral_maybe id_unf lit1+  , Just (LitString s2) <- exprIsLiteral_maybe id_unf lit2+  = Just (if s1 == s2 then trueValBool else falseValBool)++match_eq_string _ _ _ _ = Nothing+++---------------------------------------------------+-- The rule is this:+--      inline f_ty (f a b c) = <f's unfolding> a b c+-- (if f has an unfolding, EVEN if it's a loop breaker)+--+-- It's important to allow the argument to 'inline' to have args itself+-- (a) because its more forgiving to allow the programmer to write+--       inline f a b c+--   or  inline (f a b c)+-- (b) because a polymorphic f wll get a type argument that the+--     programmer can't avoid+--+-- Also, don't forget about 'inline's type argument!+match_inline :: [Expr CoreBndr] -> Maybe (Expr CoreBndr)+match_inline (Type _ : e : _)+  | (Var f, args1) <- collectArgs e,+    Just unf <- maybeUnfoldingTemplate (realIdUnfolding f)+             -- Ignore the IdUnfoldingFun here!+  = Just (mkApps unf args1)++match_inline _ = Nothing+++-- See Note [magicDictId magic] in `basicTypes/MkId.hs`+-- for a description of what is going on here.+match_magicDict :: [Expr CoreBndr] -> Maybe (Expr CoreBndr)+match_magicDict [Type _, Var wrap `App` Type a `App` Type _ `App` f, x, y ]+  | Just (fieldTy, _)   <- splitFunTy_maybe $ dropForAlls $ idType wrap+  , Just (dictTy, _)    <- splitFunTy_maybe fieldTy+  , Just dictTc         <- tyConAppTyCon_maybe dictTy+  , Just (_,_,co)       <- unwrapNewTyCon_maybe dictTc+  = Just+  $ f `App` Cast x (mkSymCo (mkUnbranchedAxInstCo Representational co [a] []))+      `App` y++match_magicDict _ = Nothing++-------------------------------------------------+-- Integer rules+--   smallInteger  (79::Int#)  = 79::Integer+--   wordToInteger (79::Word#) = 79::Integer+-- Similarly Int64, Word64++match_IntToInteger :: RuleFun+match_IntToInteger = match_IntToInteger_unop id++match_WordToInteger :: RuleFun+match_WordToInteger _ id_unf id [xl]+  | Just (LitNumber LitNumWord x _) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType id) of+    Just (_, integerTy) ->+        Just (Lit (mkLitInteger x integerTy))+    _ ->+        panic "match_WordToInteger: Id has the wrong type"+match_WordToInteger _ _ _ _ = Nothing++match_Int64ToInteger :: RuleFun+match_Int64ToInteger _ id_unf id [xl]+  | Just (LitNumber LitNumInt64 x _) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType id) of+    Just (_, integerTy) ->+        Just (Lit (mkLitInteger x integerTy))+    _ ->+        panic "match_Int64ToInteger: Id has the wrong type"+match_Int64ToInteger _ _ _ _ = Nothing++match_Word64ToInteger :: RuleFun+match_Word64ToInteger _ id_unf id [xl]+  | Just (LitNumber LitNumWord64 x _) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType id) of+    Just (_, integerTy) ->+        Just (Lit (mkLitInteger x integerTy))+    _ ->+        panic "match_Word64ToInteger: Id has the wrong type"+match_Word64ToInteger _ _ _ _ = Nothing++match_NaturalToInteger :: RuleFun+match_NaturalToInteger _ id_unf id [xl]+  | Just (LitNumber LitNumNatural x _) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType id) of+    Just (_, naturalTy) ->+        Just (Lit (LitNumber LitNumInteger x naturalTy))+    _ ->+        panic "match_NaturalToInteger: Id has the wrong type"+match_NaturalToInteger _ _ _ _ = Nothing++match_NaturalFromInteger :: RuleFun+match_NaturalFromInteger _ id_unf id [xl]+  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl+  , x >= 0+  = case splitFunTy_maybe (idType id) of+    Just (_, naturalTy) ->+        Just (Lit (LitNumber LitNumNatural x naturalTy))+    _ ->+        panic "match_NaturalFromInteger: Id has the wrong type"+match_NaturalFromInteger _ _ _ _ = Nothing++match_WordToNatural :: RuleFun+match_WordToNatural _ id_unf id [xl]+  | Just (LitNumber LitNumWord x _) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType id) of+    Just (_, naturalTy) ->+        Just (Lit (LitNumber LitNumNatural x naturalTy))+    _ ->+        panic "match_WordToNatural: Id has the wrong type"+match_WordToNatural _ _ _ _ = Nothing++-------------------------------------------------+{- Note [Rewriting bitInteger]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+For most types the bitInteger operation can be implemented in terms of shifts.+The integer-gmp package, however, can do substantially better than this if+allowed to provide its own implementation. However, in so doing it previously lost+constant-folding (see #8832). The bitInteger rule above provides constant folding+specifically for this function.++There is, however, a bit of trickiness here when it comes to ranges. While the+AST encodes all integers as Integers, `bit` expects the bit+index to be given as an Int. Hence we coerce to an Int in the rule definition.+This will behave a bit funny for constants larger than the word size, but the user+should expect some funniness given that they will have at very least ignored a+warning in this case.+-}++match_bitInteger :: RuleFun+-- Just for GHC.Integer.Type.bitInteger :: Int# -> Integer+match_bitInteger env id_unf fn [arg]+  | Just (LitNumber LitNumInt x _) <- exprIsLiteral_maybe id_unf arg+  , x >= 0+  , x <= (toInteger (platformWordSizeInBits (roPlatform env)) - 1)+    -- Make sure x is small enough to yield a decently small integer+    -- Attempting to construct the Integer for+    --    (bitInteger 9223372036854775807#)+    -- would be a bad idea (#14959)+  , let x_int = fromIntegral x :: Int+  = case splitFunTy_maybe (idType fn) of+    Just (_, integerTy)+      -> Just (Lit (LitNumber LitNumInteger (bit x_int) integerTy))+    _ -> panic "match_IntToInteger_unop: Id has the wrong type"++match_bitInteger _ _ _ _ = Nothing+++-------------------------------------------------+match_Integer_convert :: Num a+                      => (Platform -> a -> Expr CoreBndr)+                      -> RuleFun+match_Integer_convert convert env id_unf _ [xl]+  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl+  = Just (convert (roPlatform env) (fromInteger x))+match_Integer_convert _ _ _ _ _ = Nothing++match_Integer_unop :: (Integer -> Integer) -> RuleFun+match_Integer_unop unop _ id_unf _ [xl]+  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl+  = Just (Lit (LitNumber LitNumInteger (unop x) i))+match_Integer_unop _ _ _ _ _ = Nothing++match_IntToInteger_unop :: (Integer -> Integer) -> RuleFun+match_IntToInteger_unop unop _ id_unf fn [xl]+  | Just (LitNumber LitNumInt x _) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType fn) of+    Just (_, integerTy) ->+        Just (Lit (LitNumber LitNumInteger (unop x) integerTy))+    _ ->+        panic "match_IntToInteger_unop: Id has the wrong type"+match_IntToInteger_unop _ _ _ _ _ = Nothing++match_Integer_binop :: (Integer -> Integer -> Integer) -> RuleFun+match_Integer_binop binop _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl+  = Just (Lit (mkLitInteger (x `binop` y) i))+match_Integer_binop _ _ _ _ _ = Nothing++match_Natural_binop :: (Integer -> Integer -> Integer) -> RuleFun+match_Natural_binop binop _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumNatural x i) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumNatural y _) <- exprIsLiteral_maybe id_unf yl+  = Just (Lit (mkLitNatural (x `binop` y) i))+match_Natural_binop _ _ _ _ _ = Nothing++match_Natural_partial_binop :: (Integer -> Integer -> Maybe Integer) -> RuleFun+match_Natural_partial_binop binop _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumNatural x i) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumNatural y _) <- exprIsLiteral_maybe id_unf yl+  , Just z <- x `binop` y+  = Just (Lit (mkLitNatural z i))+match_Natural_partial_binop _ _ _ _ _ = Nothing++-- This helper is used for the quotRem and divMod functions+match_Integer_divop_both+   :: (Integer -> Integer -> (Integer, Integer)) -> RuleFun+match_Integer_divop_both divop _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumInteger x t) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl+  , y /= 0+  , (r,s) <- x `divop` y+  = Just $ mkCoreUbxTup [t,t] [Lit (mkLitInteger r t), Lit (mkLitInteger s t)]+match_Integer_divop_both _ _ _ _ _ = Nothing++-- This helper is used for the quot and rem functions+match_Integer_divop_one :: (Integer -> Integer -> Integer) -> RuleFun+match_Integer_divop_one divop _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl+  , y /= 0+  = Just (Lit (mkLitInteger (x `divop` y) i))+match_Integer_divop_one _ _ _ _ _ = Nothing++match_Integer_shift_op :: (Integer -> Int -> Integer) -> RuleFun+-- Used for shiftLInteger, shiftRInteger :: Integer -> Int# -> Integer+-- See Note [Guarding against silly shifts]+match_Integer_shift_op binop _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumInteger x i) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInt y _)     <- exprIsLiteral_maybe id_unf yl+  , y >= 0+  , y <= 4   -- Restrict constant-folding of shifts on Integers, somewhat+             -- arbitrary.  We can get huge shifts in inaccessible code+             -- (#15673)+  = Just (Lit (mkLitInteger (x `binop` fromIntegral y) i))+match_Integer_shift_op _ _ _ _ _ = Nothing++match_Integer_binop_Prim :: (Integer -> Integer -> Bool) -> RuleFun+match_Integer_binop_Prim binop env id_unf _ [xl, yl]+  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl+  = Just (if x `binop` y then trueValInt (roPlatform env) else falseValInt (roPlatform env))+match_Integer_binop_Prim _ _ _ _ _ = Nothing++match_Integer_binop_Ordering :: (Integer -> Integer -> Ordering) -> RuleFun+match_Integer_binop_Ordering binop _ id_unf _ [xl, yl]+  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl+  = Just $ case x `binop` y of+             LT -> ltVal+             EQ -> eqVal+             GT -> gtVal+match_Integer_binop_Ordering _ _ _ _ _ = Nothing++match_Integer_Int_encodeFloat :: RealFloat a+                              => (a -> Expr CoreBndr)+                              -> RuleFun+match_Integer_Int_encodeFloat mkLit _ id_unf _ [xl,yl]+  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInt y _)     <- exprIsLiteral_maybe id_unf yl+  = Just (mkLit $ encodeFloat x (fromInteger y))+match_Integer_Int_encodeFloat _ _ _ _ _ = Nothing++---------------------------------------------------+-- constant folding for Float/Double+--+-- This turns+--      rationalToFloat n d+-- into a literal Float, and similarly for Doubles.+--+-- it's important to not match d == 0, because that may represent a+-- literal "0/0" or similar, and we can't produce a literal value for+-- NaN or +-Inf+match_rationalTo :: RealFloat a+                 => (a -> Expr CoreBndr)+                 -> RuleFun+match_rationalTo mkLit _ id_unf _ [xl, yl]+  | Just (LitNumber LitNumInteger x _) <- exprIsLiteral_maybe id_unf xl+  , Just (LitNumber LitNumInteger y _) <- exprIsLiteral_maybe id_unf yl+  , y /= 0+  = Just (mkLit (fromRational (x % y)))+match_rationalTo _ _ _ _ _ = Nothing++match_decodeDouble :: RuleFun+match_decodeDouble env id_unf fn [xl]+  | Just (LitDouble x) <- exprIsLiteral_maybe id_unf xl+  = case splitFunTy_maybe (idType fn) of+    Just (_, res)+      | Just [_lev1, _lev2, integerTy, intHashTy] <- tyConAppArgs_maybe res+      -> case decodeFloat (fromRational x :: Double) of+           (y, z) ->+             Just $ mkCoreUbxTup [integerTy, intHashTy]+                                 [Lit (mkLitInteger y integerTy),+                                  Lit (mkLitInt (roPlatform env) (toInteger z))]+    _ ->+        pprPanic "match_decodeDouble: Id has the wrong type"+          (ppr fn <+> dcolon <+> ppr (idType fn))+match_decodeDouble _ _ _ _ = Nothing++match_XToIntegerToX :: Name -> RuleFun+match_XToIntegerToX n _ _ _ [App (Var x) y]+  | idName x == n+  = Just y+match_XToIntegerToX _ _ _ _ _ = Nothing++match_smallIntegerTo :: PrimOp -> RuleFun+match_smallIntegerTo primOp _ _ _ [App (Var x) y]+  | idName x == smallIntegerName+  = Just $ App (Var (mkPrimOpId primOp)) y+match_smallIntegerTo _ _ _ _ _ = Nothing++++--------------------------------------------------------+-- Note [Constant folding through nested expressions]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- We use rewrites rules to perform constant folding. It means that we don't+-- have a global view of the expression we are trying to optimise. As a+-- consequence we only perform local (small-step) transformations that either:+--    1) reduce the number of operations+--    2) rearrange the expression to increase the odds that other rules will+--    match+--+-- We don't try to handle more complex expression optimisation cases that would+-- require a global view. For example, rewriting expressions to increase+-- sharing (e.g., Horner's method); optimisations that require local+-- transformations increasing the number of operations; rearrangements to+-- cancel/factorize terms (e.g., (a+b-a-b) isn't rearranged to reduce to 0).+--+-- We already have rules to perform constant folding on expressions with the+-- following shape (where a and/or b are literals):+--+--          D)    op+--                /\+--               /  \+--              /    \+--             a      b+--+-- To support nested expressions, we match three other shapes of expression+-- trees:+--+-- A)   op1          B)       op1       C)       op1+--      /\                    /\                 /\+--     /  \                  /  \               /  \+--    /    \                /    \             /    \+--   a     op2            op2     c          op2    op3+--          /\            /\                 /\      /\+--         /  \          /  \               /  \    /  \+--        b    c        a    b             a    b  c    d+--+--+-- R1) +/- simplification:+--    ops = + or -, two literals (not siblings)+--+--    Examples:+--       A: 5 + (10-x)  ==> 15-x+--       B: (10+x) + 5  ==> 15+x+--       C: (5+a)-(5-b) ==> 0+(a+b)+--+-- R2) * simplification+--    ops = *, two literals (not siblings)+--+--    Examples:+--       A: 5 * (10*x)  ==> 50*x+--       B: (10*x) * 5  ==> 50*x+--       C: (5*a)*(5*b) ==> 25*(a*b)+--+-- R3) * distribution over +/-+--    op1 = *, op2 = + or -, two literals (not siblings)+--+--    This transformation doesn't reduce the number of operations but switches+--    the outer and the inner operations so that the outer is (+) or (-) instead+--    of (*). It increases the odds that other rules will match after this one.+--+--    Examples:+--       A: 5 * (10-x)  ==> 50 - (5*x)+--       B: (10+x) * 5  ==> 50 + (5*x)+--       C: Not supported as it would increase the number of operations:+--          (5+a)*(5-b) ==> 25 - 5*b + 5*a - a*b+--+-- R4) Simple factorization+--+--    op1 = + or -, op2/op3 = *,+--    one literal for each innermost * operation (except in the D case),+--    the two other terms are equals+--+--    Examples:+--       A: x - (10*x)  ==> (-9)*x+--       B: (10*x) + x  ==> 11*x+--       C: (5*x)-(x*3) ==> 2*x+--       D: x+x         ==> 2*x+--+-- R5) +/- propagation+--+--    ops = + or -, one literal+--+--    This transformation doesn't reduce the number of operations but propagates+--    the constant to the outer level. It increases the odds that other rules+--    will match after this one.+--+--    Examples:+--       A: x - (10-y)  ==> (x+y) - 10+--       B: (10+x) - y  ==> 10 + (x-y)+--       C: N/A (caught by the A and B cases)+--+--------------------------------------------------------++-- | Rules to perform constant folding into nested expressions+--+--See Note [Constant folding through nested expressions]+numFoldingRules :: PrimOp -> (Platform -> PrimOps) -> RuleM CoreExpr+numFoldingRules op dict = do+  env <- getEnv+  if not (roNumConstantFolding env)+   then mzero+   else do+    [e1,e2] <- getArgs+    platform <- getPlatform+    let PrimOps{..} = dict platform+    case BinOpApp e1 op e2 of+     -- R1) +/- simplification+     x    :++: (y :++: v)          -> return $ mkL (x+y)   `add` v+     x    :++: (L y :-: v)         -> return $ mkL (x+y)   `sub` v+     x    :++: (v   :-: L y)       -> return $ mkL (x-y)   `add` v+     L x  :-:  (y :++: v)          -> return $ mkL (x-y)   `sub` v+     L x  :-:  (L y :-: v)         -> return $ mkL (x-y)   `add` v+     L x  :-:  (v   :-: L y)       -> return $ mkL (x+y)   `sub` v++     (y :++: v)    :-: L x         -> return $ mkL (y-x)   `add` v+     (L y :-: v)   :-: L x         -> return $ mkL (y-x)   `sub` v+     (v   :-: L y) :-: L x         -> return $ mkL (0-y-x) `add` v++     (x :++: w)  :+: (y :++: v)    -> return $ mkL (x+y)   `add` (w `add` v)+     (w :-: L x) :+: (L y :-: v)   -> return $ mkL (y-x)   `add` (w `sub` v)+     (w :-: L x) :+: (v   :-: L y) -> return $ mkL (0-x-y) `add` (w `add` v)+     (L x :-: w) :+: (L y :-: v)   -> return $ mkL (x+y)   `sub` (w `add` v)+     (L x :-: w) :+: (v   :-: L y) -> return $ mkL (x-y)   `add` (v `sub` w)+     (w :-: L x) :+: (y :++: v)    -> return $ mkL (y-x)   `add` (w `add` v)+     (L x :-: w) :+: (y :++: v)    -> return $ mkL (x+y)   `add` (v `sub` w)+     (y :++: v)  :+: (w :-: L x)   -> return $ mkL (y-x)   `add` (w `add` v)+     (y :++: v)  :+: (L x :-: w)   -> return $ mkL (x+y)   `add` (v `sub` w)++     (v   :-: L y) :-: (w :-: L x) -> return $ mkL (x-y)   `add` (v `sub` w)+     (v   :-: L y) :-: (L x :-: w) -> return $ mkL (0-x-y) `add` (v `add` w)+     (L y :-:   v) :-: (w :-: L x) -> return $ mkL (x+y)   `sub` (v `add` w)+     (L y :-:   v) :-: (L x :-: w) -> return $ mkL (y-x)   `add` (w `sub` v)+     (x :++: w)    :-: (y :++: v)  -> return $ mkL (x-y)   `add` (w `sub` v)+     (w :-: L x)   :-: (y :++: v)  -> return $ mkL (0-y-x) `add` (w `sub` v)+     (L x :-: w)   :-: (y :++: v)  -> return $ mkL (x-y)   `sub` (v `add` w)+     (y :++: v)    :-: (w :-: L x) -> return $ mkL (y+x)   `add` (v `sub` w)+     (y :++: v)    :-: (L x :-: w) -> return $ mkL (y-x)   `add` (v `add` w)++     -- R2) * simplification+     x :**: (y :**: v)             -> return $ mkL (x*y)   `mul` v+     (x :**: w) :*: (y :**: v)     -> return $ mkL (x*y)   `mul` (w `mul` v)++     -- R3) * distribution over +/-+     x :**: (y :++: v)             -> return $ mkL (x*y)   `add` (mkL x `mul` v)+     x :**: (L y :-: v)            -> return $ mkL (x*y)   `sub` (mkL x `mul` v)+     x :**: (v   :-: L y)          -> return $ (mkL x `mul` v) `sub` mkL (x*y)++     -- R4) Simple factorization+     v :+: w+      | w `cheapEqExpr` v          -> return $ mkL 2       `mul` v+     w :+: (y :**: v)+      | w `cheapEqExpr` v          -> return $ mkL (1+y)   `mul` v+     w :-: (y :**: v)+      | w `cheapEqExpr` v          -> return $ mkL (1-y)   `mul` v+     (y :**: v) :+: w+      | w `cheapEqExpr` v          -> return $ mkL (y+1)   `mul` v+     (y :**: v) :-: w+      | w `cheapEqExpr` v          -> return $ mkL (y-1)   `mul` v+     (x :**: w) :+: (y :**: v)+      | w `cheapEqExpr` v          -> return $ mkL (x+y)   `mul` v+     (x :**: w) :-: (y :**: v)+      | w `cheapEqExpr` v          -> return $ mkL (x-y)   `mul` v++     -- R5) +/- propagation+     w  :+: (y :++: v)             -> return $ mkL y `add` (w `add` v)+     (y :++: v) :+: w              -> return $ mkL y       `add` (w `add` v)+     w  :-: (y :++: v)             -> return $ (w `sub` v) `sub` mkL y+     (y :++: v) :-: w              -> return $ mkL y       `add` (v `sub` w)+     w    :-: (L y :-: v)          -> return $ (w `add` v) `sub` mkL y+     (L y :-: v) :-: w             -> return $ mkL y       `sub` (w `add` v)+     w    :+: (L y :-: v)          -> return $ mkL y       `add` (w `sub` v)+     w    :+: (v :-: L y)          -> return $ (w `add` v) `sub` mkL y+     (L y :-: v) :+: w             -> return $ mkL y       `add` (w `sub` v)+     (v :-: L y) :+: w             -> return $ (w `add` v) `sub` mkL y++     _                             -> mzero++++-- | Match the application of a binary primop+pattern BinOpApp  :: Arg CoreBndr -> PrimOp -> Arg CoreBndr -> CoreExpr+pattern BinOpApp  x op y =  OpVal op `App` x `App` y++-- | Match a primop+pattern OpVal   :: PrimOp  -> Arg CoreBndr+pattern OpVal   op     <- Var (isPrimOpId_maybe -> Just op) where+   OpVal op = Var (mkPrimOpId op)++++-- | Match a literal+pattern L :: Integer -> Arg CoreBndr+pattern L l <- Lit (isLitValue_maybe -> Just l)++-- | Match an addition+pattern (:+:) :: Arg CoreBndr -> Arg CoreBndr -> CoreExpr+pattern x :+: y <- BinOpApp x (isAddOp -> True) y++-- | Match an addition with a literal (handle commutativity)+pattern (:++:) :: Integer -> Arg CoreBndr -> CoreExpr+pattern l :++: x <- (isAdd -> Just (l,x))++isAdd :: CoreExpr -> Maybe (Integer,CoreExpr)+isAdd e = case e of+   L l :+: x   -> Just (l,x)+   x   :+: L l -> Just (l,x)+   _           -> Nothing++-- | Match a multiplication+pattern (:*:) :: Arg CoreBndr -> Arg CoreBndr -> CoreExpr+pattern x :*: y <- BinOpApp x (isMulOp -> True) y++-- | Match a multiplication with a literal (handle commutativity)+pattern (:**:) :: Integer -> Arg CoreBndr -> CoreExpr+pattern l :**: x <- (isMul -> Just (l,x))++isMul :: CoreExpr -> Maybe (Integer,CoreExpr)+isMul e = case e of+   L l :*: x   -> Just (l,x)+   x   :*: L l -> Just (l,x)+   _           -> Nothing+++-- | Match a subtraction+pattern (:-:) :: Arg CoreBndr -> Arg CoreBndr -> CoreExpr+pattern x :-: y <- BinOpApp x (isSubOp -> True) y++isSubOp :: PrimOp -> Bool+isSubOp IntSubOp  = True+isSubOp WordSubOp = True+isSubOp _         = False++isAddOp :: PrimOp -> Bool+isAddOp IntAddOp  = True+isAddOp WordAddOp = True+isAddOp _         = False++isMulOp :: PrimOp -> Bool+isMulOp IntMulOp  = True+isMulOp WordMulOp = True+isMulOp _         = False++-- | Explicit "type-class"-like dictionary for numeric primops+--+-- Depends on Platform because creating a literal value depends on Platform+data PrimOps = PrimOps+   { add :: CoreExpr -> CoreExpr -> CoreExpr -- ^ Add two numbers+   , sub :: CoreExpr -> CoreExpr -> CoreExpr -- ^ Sub two numbers+   , mul :: CoreExpr -> CoreExpr -> CoreExpr -- ^ Multiply two numbers+   , mkL :: Integer -> CoreExpr              -- ^ Create a literal value+   }++intPrimOps :: Platform -> PrimOps+intPrimOps platform = PrimOps+   { add = \x y -> BinOpApp x IntAddOp y+   , sub = \x y -> BinOpApp x IntSubOp y+   , mul = \x y -> BinOpApp x IntMulOp y+   , mkL = intResult' platform+   }++wordPrimOps :: Platform -> PrimOps+wordPrimOps platform = PrimOps+   { add = \x y -> BinOpApp x WordAddOp y+   , sub = \x y -> BinOpApp x WordSubOp y+   , mul = \x y -> BinOpApp x WordMulOp y+   , mkL = wordResult' platform+   }+++--------------------------------------------------------+-- Constant folding through case-expressions+--+-- cf Scrutinee Constant Folding in simplCore/GHC.Core.Opt.Simplify.Utils+--------------------------------------------------------++-- | Match the scrutinee of a case and potentially return a new scrutinee and a+-- function to apply to each literal alternative.+caseRules :: Platform+          -> CoreExpr                       -- Scrutinee+          -> Maybe ( CoreExpr               -- New scrutinee+                   , AltCon -> Maybe AltCon -- How to fix up the alt pattern+                                            --   Nothing <=> Unreachable+                                            -- See Note [Unreachable caseRules alternatives]+                   , Id -> CoreExpr)        -- How to reconstruct the original scrutinee+                                            -- from the new case-binder+-- e.g  case e of b {+--         ...;+--         con bs -> rhs;+--         ... }+--  ==>+--      case e' of b' {+--         ...;+--         fixup_altcon[con] bs -> let b = mk_orig[b] in rhs;+--         ... }++caseRules platform (App (App (Var f) v) (Lit l))   -- v `op` x#+  | Just op <- isPrimOpId_maybe f+  , Just x  <- isLitValue_maybe l+  , Just adjust_lit <- adjustDyadicRight op x+  = Just (v, tx_lit_con platform adjust_lit+           , \v -> (App (App (Var f) (Var v)) (Lit l)))++caseRules platform (App (App (Var f) (Lit l)) v)   -- x# `op` v+  | Just op <- isPrimOpId_maybe f+  , Just x  <- isLitValue_maybe l+  , Just adjust_lit <- adjustDyadicLeft x op+  = Just (v, tx_lit_con platform adjust_lit+           , \v -> (App (App (Var f) (Lit l)) (Var v)))+++caseRules platform (App (Var f) v              )   -- op v+  | Just op <- isPrimOpId_maybe f+  , Just adjust_lit <- adjustUnary op+  = Just (v, tx_lit_con platform adjust_lit+           , \v -> App (Var f) (Var v))++-- See Note [caseRules for tagToEnum]+caseRules platform (App (App (Var f) type_arg) v)+  | Just TagToEnumOp <- isPrimOpId_maybe f+  = Just (v, tx_con_tte platform+           , \v -> (App (App (Var f) type_arg) (Var v)))++-- See Note [caseRules for dataToTag]+caseRules _ (App (App (Var f) (Type ty)) v)       -- dataToTag x+  | Just DataToTagOp <- isPrimOpId_maybe f+  , Just (tc, _) <- tcSplitTyConApp_maybe ty+  , isAlgTyCon tc+  = Just (v, tx_con_dtt ty+           , \v -> App (App (Var f) (Type ty)) (Var v))++caseRules _ _ = Nothing+++tx_lit_con :: Platform -> (Integer -> Integer) -> AltCon -> Maybe AltCon+tx_lit_con _        _      DEFAULT    = Just DEFAULT+tx_lit_con platform adjust (LitAlt l) = Just $ LitAlt (mapLitValue platform adjust l)+tx_lit_con _        _      alt        = pprPanic "caseRules" (ppr alt)+   -- NB: mapLitValue uses mkLitIntWrap etc, to ensure that the+   -- literal alternatives remain in Word/Int target ranges+   -- (See Note [Word/Int underflow/overflow] in GHC.Types.Literal and #13172).++adjustDyadicRight :: PrimOp -> Integer -> Maybe (Integer -> Integer)+-- Given (x `op` lit) return a function 'f' s.t.  f (x `op` lit) = x+adjustDyadicRight op lit+  = case op of+         WordAddOp -> Just (\y -> y-lit      )+         IntAddOp  -> Just (\y -> y-lit      )+         WordSubOp -> Just (\y -> y+lit      )+         IntSubOp  -> Just (\y -> y+lit      )+         XorOp     -> Just (\y -> y `xor` lit)+         XorIOp    -> Just (\y -> y `xor` lit)+         _         -> Nothing++adjustDyadicLeft :: Integer -> PrimOp -> Maybe (Integer -> Integer)+-- Given (lit `op` x) return a function 'f' s.t.  f (lit `op` x) = x+adjustDyadicLeft lit op+  = case op of+         WordAddOp -> Just (\y -> y-lit      )+         IntAddOp  -> Just (\y -> y-lit      )+         WordSubOp -> Just (\y -> lit-y      )+         IntSubOp  -> Just (\y -> lit-y      )+         XorOp     -> Just (\y -> y `xor` lit)+         XorIOp    -> Just (\y -> y `xor` lit)+         _         -> Nothing+++adjustUnary :: PrimOp -> Maybe (Integer -> Integer)+-- Given (op x) return a function 'f' s.t.  f (op x) = x+adjustUnary op+  = case op of+         NotOp     -> Just (\y -> complement y)+         NotIOp    -> Just (\y -> complement y)+         IntNegOp  -> Just (\y -> negate y    )+         _         -> Nothing++tx_con_tte :: Platform -> AltCon -> Maybe AltCon+tx_con_tte _        DEFAULT         = Just DEFAULT+tx_con_tte _        alt@(LitAlt {}) = pprPanic "caseRules" (ppr alt)+tx_con_tte platform (DataAlt dc)  -- See Note [caseRules for tagToEnum]+  = Just $ LitAlt $ mkLitInt platform $ toInteger $ dataConTagZ dc++tx_con_dtt :: Type -> AltCon -> Maybe AltCon+tx_con_dtt _  DEFAULT = Just DEFAULT+tx_con_dtt ty (LitAlt (LitNumber LitNumInt i _))+   | tag >= 0+   , tag < n_data_cons+   = Just (DataAlt (data_cons !! tag))   -- tag is zero-indexed, as is (!!)+   | otherwise+   = Nothing+   where+     tag         = fromInteger i :: ConTagZ+     tc          = tyConAppTyCon ty+     n_data_cons = tyConFamilySize tc+     data_cons   = tyConDataCons tc++tx_con_dtt _ alt = pprPanic "caseRules" (ppr alt)+++{- Note [caseRules for tagToEnum]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We want to transform+   case tagToEnum x of+     False -> e1+     True  -> e2+into+   case x of+     0# -> e1+     1# -> e2++This rule eliminates a lot of boilerplate. For+  if (x>y) then e2 else e1+we generate+  case tagToEnum (x ># y) of+    False -> e1+    True  -> e2+and it is nice to then get rid of the tagToEnum.++Beware (#14768): avoid the temptation to map constructor 0 to+DEFAULT, in the hope of getting this+  case (x ># y) of+    DEFAULT -> e1+    1#      -> e2+That fails utterly in the case of+   data Colour = Red | Green | Blue+   case tagToEnum x of+      DEFAULT -> e1+      Red     -> e2++We don't want to get this!+   case x of+      DEFAULT -> e1+      DEFAULT -> e2++Instead, we deal with turning one branch into DEFAULT in GHC.Core.Opt.Simplify.Utils+(add_default in mkCase3).++Note [caseRules for dataToTag]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+See also Note [dataToTag#] in primpops.txt.pp++We want to transform+  case dataToTag x of+    DEFAULT -> e1+    1# -> e2+into+  case x of+    DEFAULT -> e1+    (:) _ _ -> e2++Note the need for some wildcard binders in+the 'cons' case.++For the time, we only apply this transformation when the type of `x` is a type+headed by a normal tycon. In particular, we do not apply this in the case of a+data family tycon, since that would require carefully applying coercion(s)+between the data family and the data family instance's representation type,+which caseRules isn't currently engineered to handle (#14680).++Note [Unreachable caseRules alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Take care if we see something like+  case dataToTag x of+    DEFAULT -> e1+    -1# -> e2+    100 -> e3+because there isn't a data constructor with tag -1 or 100. In this case the+out-of-range alternative is dead code -- we know the range of tags for x.++Hence caseRules returns (AltCon -> Maybe AltCon), with Nothing indicating+an alternative that is unreachable.++You may wonder how this can happen: check out #15436.+-}
+ compiler/GHC/Core/Opt/Monad.hs view
@@ -0,0 +1,828 @@+{-+(c) The AQUA Project, Glasgow University, 1993-1998++-}++{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveFunctor #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++module GHC.Core.Opt.Monad (+    -- * Configuration of the core-to-core passes+    CoreToDo(..), runWhen, runMaybe,+    SimplMode(..),+    FloatOutSwitches(..),+    pprPassDetails,++    -- * Plugins+    CorePluginPass, bindsOnlyPass,++    -- * Counting+    SimplCount, doSimplTick, doFreeSimplTick, simplCountN,+    pprSimplCount, plusSimplCount, zeroSimplCount,+    isZeroSimplCount, hasDetailedCounts, Tick(..),++    -- * The monad+    CoreM, runCoreM,++    -- ** Reading from the monad+    getHscEnv, getRuleBase, getModule,+    getDynFlags, getPackageFamInstEnv,+    getVisibleOrphanMods, getUniqMask,+    getPrintUnqualified, getSrcSpanM,++    -- ** Writing to the monad+    addSimplCount,++    -- ** Lifting into the monad+    liftIO, liftIOWithCount,++    -- ** Dealing with annotations+    getAnnotations, getFirstAnnotations,++    -- ** Screen output+    putMsg, putMsgS, errorMsg, errorMsgS, warnMsg,+    fatalErrorMsg, fatalErrorMsgS,+    debugTraceMsg, debugTraceMsgS,+    dumpIfSet_dyn+  ) where++import GHC.Prelude hiding ( read )++import GHC.Core+import GHC.Driver.Types+import GHC.Unit.Module+import GHC.Driver.Session+import GHC.Types.Basic  ( CompilerPhase(..) )+import GHC.Types.Annotations++import GHC.Data.IOEnv hiding     ( liftIO, failM, failWithM )+import qualified GHC.Data.IOEnv  as IOEnv+import GHC.Types.Var+import GHC.Utils.Outputable as Outputable+import GHC.Data.FastString+import GHC.Utils.Error( Severity(..), DumpFormat (..), dumpOptionsFromFlag )+import GHC.Types.Unique.Supply+import GHC.Utils.Monad+import GHC.Types.Name.Env+import GHC.Types.SrcLoc+import Data.Bifunctor ( bimap )+import GHC.Utils.Error (dumpAction)+import Data.List (intersperse, groupBy, sortBy)+import Data.Ord+import Data.Dynamic+import Data.Map (Map)+import qualified Data.Map as Map+import qualified Data.Map.Strict as MapStrict+import Data.Word+import Control.Monad+import Control.Applicative ( Alternative(..) )+import GHC.Utils.Panic (throwGhcException, GhcException(..))++{-+************************************************************************+*                                                                      *+              The CoreToDo type and related types+          Abstraction of core-to-core passes to run.+*                                                                      *+************************************************************************+-}++data CoreToDo           -- These are diff core-to-core passes,+                        -- which may be invoked in any order,+                        -- as many times as you like.++  = CoreDoSimplify      -- The core-to-core simplifier.+        Int                    -- Max iterations+        SimplMode+  | CoreDoPluginPass String CorePluginPass+  | CoreDoFloatInwards+  | CoreDoFloatOutwards FloatOutSwitches+  | CoreLiberateCase+  | CoreDoPrintCore+  | CoreDoStaticArgs+  | CoreDoCallArity+  | CoreDoExitify+  | CoreDoDemand+  | CoreDoCpr+  | CoreDoWorkerWrapper+  | CoreDoSpecialising+  | CoreDoSpecConstr+  | CoreCSE+  | CoreDoRuleCheck CompilerPhase String   -- Check for non-application of rules+                                           -- matching this string+  | CoreDoNothing                -- Useful when building up+  | CoreDoPasses [CoreToDo]      -- lists of these things++  | CoreDesugar    -- Right after desugaring, no simple optimisation yet!+  | CoreDesugarOpt -- CoreDesugarXXX: Not strictly a core-to-core pass, but produces+                       --                 Core output, and hence useful to pass to endPass++  | CoreTidy+  | CorePrep+  | CoreOccurAnal++instance Outputable CoreToDo where+  ppr (CoreDoSimplify _ _)     = text "Simplifier"+  ppr (CoreDoPluginPass s _)   = text "Core plugin: " <+> text s+  ppr CoreDoFloatInwards       = text "Float inwards"+  ppr (CoreDoFloatOutwards f)  = text "Float out" <> parens (ppr f)+  ppr CoreLiberateCase         = text "Liberate case"+  ppr CoreDoStaticArgs         = text "Static argument"+  ppr CoreDoCallArity          = text "Called arity analysis"+  ppr CoreDoExitify            = text "Exitification transformation"+  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"+  ppr CoreCSE                  = text "Common sub-expression"+  ppr CoreDesugar              = text "Desugar (before optimization)"+  ppr CoreDesugarOpt           = text "Desugar (after optimization)"+  ppr CoreTidy                 = text "Tidy Core"+  ppr CorePrep                 = text "CorePrep"+  ppr CoreOccurAnal            = text "Occurrence analysis"+  ppr CoreDoPrintCore          = text "Print core"+  ppr (CoreDoRuleCheck {})     = text "Rule check"+  ppr CoreDoNothing            = text "CoreDoNothing"+  ppr (CoreDoPasses passes)    = text "CoreDoPasses" <+> ppr passes++pprPassDetails :: CoreToDo -> SDoc+pprPassDetails (CoreDoSimplify n md) = vcat [ text "Max iterations =" <+> int n+                                            , ppr md ]+pprPassDetails _ = Outputable.empty++data SimplMode             -- See comments in GHC.Core.Opt.Simplify.Monad+  = SimplMode+        { sm_names      :: [String] -- Name(s) of the phase+        , sm_phase      :: CompilerPhase+        , sm_dflags     :: DynFlags -- Just for convenient non-monadic+                                    -- access; we don't override these+        , sm_rules      :: Bool     -- Whether RULES are enabled+        , sm_inline     :: Bool     -- Whether inlining is enabled+        , sm_case_case  :: Bool     -- Whether case-of-case is enabled+        , sm_eta_expand :: Bool     -- Whether eta-expansion is enabled+        }++instance Outputable SimplMode where+    ppr (SimplMode { sm_phase = p, sm_names = ss+                   , sm_rules = r, sm_inline = i+                   , sm_eta_expand = eta, sm_case_case = cc })+       = text "SimplMode" <+> braces (+         sep [ text "Phase =" <+> ppr p <+>+               brackets (text (concat $ intersperse "," ss)) <> comma+             , pp_flag i   (sLit "inline") <> comma+             , pp_flag r   (sLit "rules") <> comma+             , pp_flag eta (sLit "eta-expand") <> comma+             , pp_flag cc  (sLit "case-of-case") ])+         where+           pp_flag f s = ppUnless f (text "no") <+> ptext s++data FloatOutSwitches = FloatOutSwitches {+  floatOutLambdas   :: Maybe Int,  -- ^ Just n <=> float lambdas to top level, if+                                   -- doing so will abstract over n or fewer+                                   -- value variables+                                   -- Nothing <=> float all lambdas to top level,+                                   --             regardless of how many free variables+                                   -- Just 0 is the vanilla case: float a lambda+                                   --    iff it has no free vars++  floatOutConstants :: Bool,       -- ^ True <=> float constants to top level,+                                   --            even if they do not escape a lambda+  floatOutOverSatApps :: Bool,+                             -- ^ True <=> float out over-saturated applications+                             --            based on arity information.+                             -- See Note [Floating over-saturated applications]+                             -- in GHC.Core.Opt.SetLevels+  floatToTopLevelOnly :: Bool      -- ^ Allow floating to the top level only.+  }+instance Outputable FloatOutSwitches where+    ppr = pprFloatOutSwitches++pprFloatOutSwitches :: FloatOutSwitches -> SDoc+pprFloatOutSwitches sw+  = text "FOS" <+> (braces $+     sep $ punctuate comma $+     [ text "Lam ="    <+> ppr (floatOutLambdas sw)+     , text "Consts =" <+> ppr (floatOutConstants sw)+     , text "OverSatApps ="   <+> ppr (floatOutOverSatApps sw) ])++-- The core-to-core pass ordering is derived from the DynFlags:+runWhen :: Bool -> CoreToDo -> CoreToDo+runWhen True  do_this = do_this+runWhen False _       = CoreDoNothing++runMaybe :: Maybe a -> (a -> CoreToDo) -> CoreToDo+runMaybe (Just x) f = f x+runMaybe Nothing  _ = CoreDoNothing++{-++************************************************************************+*                                                                      *+             Types for Plugins+*                                                                      *+************************************************************************+-}++-- | A description of the plugin pass itself+type CorePluginPass = ModGuts -> CoreM ModGuts++bindsOnlyPass :: (CoreProgram -> CoreM CoreProgram) -> ModGuts -> CoreM ModGuts+bindsOnlyPass pass guts+  = do { binds' <- pass (mg_binds guts)+       ; return (guts { mg_binds = binds' }) }++{-+************************************************************************+*                                                                      *+             Counting and logging+*                                                                      *+************************************************************************+-}++getVerboseSimplStats :: (Bool -> SDoc) -> SDoc+getVerboseSimplStats = getPprDebug          -- For now, anyway++zeroSimplCount     :: DynFlags -> SimplCount+isZeroSimplCount   :: SimplCount -> Bool+hasDetailedCounts  :: SimplCount -> Bool+pprSimplCount      :: SimplCount -> SDoc+doSimplTick        :: DynFlags -> Tick -> SimplCount -> SimplCount+doFreeSimplTick    ::             Tick -> SimplCount -> SimplCount+plusSimplCount     :: SimplCount -> SimplCount -> SimplCount++data SimplCount+   = VerySimplCount !Int        -- Used when don't want detailed stats++   | SimplCount {+        ticks   :: !Int,        -- Total ticks+        details :: !TickCounts, -- How many of each type++        n_log   :: !Int,        -- N+        log1    :: [Tick],      -- Last N events; <= opt_HistorySize,+                                --   most recent first+        log2    :: [Tick]       -- Last opt_HistorySize events before that+                                -- Having log1, log2 lets us accumulate the+                                -- recent history reasonably efficiently+     }++type TickCounts = Map Tick Int++simplCountN :: SimplCount -> Int+simplCountN (VerySimplCount n)         = n+simplCountN (SimplCount { ticks = n }) = n++zeroSimplCount dflags+                -- This is where we decide whether to do+                -- the VerySimpl version or the full-stats version+  | dopt Opt_D_dump_simpl_stats dflags+  = SimplCount {ticks = 0, details = Map.empty,+                n_log = 0, log1 = [], log2 = []}+  | otherwise+  = VerySimplCount 0++isZeroSimplCount (VerySimplCount n)         = n==0+isZeroSimplCount (SimplCount { ticks = n }) = n==0++hasDetailedCounts (VerySimplCount {}) = False+hasDetailedCounts (SimplCount {})     = True++doFreeSimplTick tick sc@SimplCount { details = dts }+  = sc { details = dts `addTick` tick }+doFreeSimplTick _ sc = sc++doSimplTick dflags tick+    sc@(SimplCount { ticks = tks, details = dts, n_log = nl, log1 = l1 })+  | nl >= historySize dflags = sc1 { n_log = 1, log1 = [tick], log2 = l1 }+  | otherwise                = sc1 { n_log = nl+1, log1 = tick : l1 }+  where+    sc1 = sc { ticks = tks+1, details = dts `addTick` tick }++doSimplTick _ _ (VerySimplCount n) = VerySimplCount (n+1)+++addTick :: TickCounts -> Tick -> TickCounts+addTick fm tick = MapStrict.insertWith (+) tick 1 fm++plusSimplCount sc1@(SimplCount { ticks = tks1, details = dts1 })+               sc2@(SimplCount { ticks = tks2, details = dts2 })+  = log_base { ticks = tks1 + tks2+             , details = MapStrict.unionWith (+) dts1 dts2 }+  where+        -- A hackish way of getting recent log info+    log_base | null (log1 sc2) = sc1    -- Nothing at all in sc2+             | null (log2 sc2) = sc2 { log2 = log1 sc1 }+             | otherwise       = sc2++plusSimplCount (VerySimplCount n) (VerySimplCount m) = VerySimplCount (n+m)+plusSimplCount lhs                rhs                =+  throwGhcException . PprProgramError "plusSimplCount" $ vcat+    [ text "lhs"+    , pprSimplCount lhs+    , text "rhs"+    , pprSimplCount rhs+    ]+       -- We use one or the other consistently++pprSimplCount (VerySimplCount n) = text "Total ticks:" <+> int n+pprSimplCount (SimplCount { ticks = tks, details = dts, log1 = l1, log2 = l2 })+  = vcat [text "Total ticks:    " <+> int tks,+          blankLine,+          pprTickCounts dts,+          getVerboseSimplStats $ \dbg -> if dbg+          then+                vcat [blankLine,+                      text "Log (most recent first)",+                      nest 4 (vcat (map ppr l1) $$ vcat (map ppr l2))]+          else Outputable.empty+    ]++{- Note [Which transformations are innocuous]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+At one point (Jun 18) I wondered if some transformations (ticks)+might be  "innocuous", in the sense that they do not unlock a later+transformation that does not occur in the same pass.  If so, we could+refrain from bumping the overall tick-count for such innocuous+transformations, and perhaps terminate the simplifier one pass+earlier.++But alas I found that virtually nothing was innocuous!  This Note+just records what I learned, in case anyone wants to try again.++These transformations are not innocuous:++*** NB: I think these ones could be made innocuous+          EtaExpansion+          LetFloatFromLet++LetFloatFromLet+    x = K (let z = e2 in Just z)+  prepareRhs transforms to+    x2 = let z=e2 in Just z+    x  = K xs+  And now more let-floating can happen in the+  next pass, on x2++PreInlineUnconditionally+  Example in spectral/cichelli/Auxil+     hinsert = ...let lo = e in+                  let j = ...lo... in+                  case x of+                    False -> ()+                    True -> case lo of I# lo' ->+                              ...j...+  When we PreInlineUnconditionally j, lo's occ-info changes to once,+  so it can be PreInlineUnconditionally in the next pass, and a+  cascade of further things can happen.++PostInlineUnconditionally+  let x = e in+  let y = ...x.. in+  case .. of { A -> ...x...y...+               B -> ...x...y... }+  Current postinlineUnconditinaly will inline y, and then x; sigh.++  But PostInlineUnconditionally might also unlock subsequent+  transformations for the same reason as PreInlineUnconditionally,+  so it's probably not innocuous anyway.++KnownBranch, BetaReduction:+  May drop chunks of code, and thereby enable PreInlineUnconditionally+  for some let-binding which now occurs once++EtaExpansion:+  Example in imaginary/digits-of-e1+    fail = \void. e          where e :: IO ()+  --> etaExpandRhs+    fail = \void. (\s. (e |> g) s) |> sym g      where g :: IO () ~ S -> (S,())+  --> Next iteration of simplify+    fail1 = \void. \s. (e |> g) s+    fail = fail1 |> Void#->sym g+  And now inline 'fail'++CaseMerge:+  case x of y {+    DEFAULT -> case y of z { pi -> ei }+    alts2 }+  ---> CaseMerge+    case x of { pi -> let z = y in ei+              ; alts2 }+  The "let z=y" case-binder-swap gets dealt with in the next pass+-}++pprTickCounts :: Map Tick Int -> SDoc+pprTickCounts counts+  = vcat (map pprTickGroup groups)+  where+    groups :: [[(Tick,Int)]]    -- Each group shares a common tag+                                -- toList returns common tags adjacent+    groups = groupBy same_tag (Map.toList counts)+    same_tag (tick1,_) (tick2,_) = tickToTag tick1 == tickToTag tick2++pprTickGroup :: [(Tick, Int)] -> SDoc+pprTickGroup group@((tick1,_):_)+  = hang (int (sum [n | (_,n) <- group]) <+> text (tickString tick1))+       2 (vcat [ int n <+> pprTickCts tick+                                    -- flip as we want largest first+               | (tick,n) <- sortBy (flip (comparing snd)) group])+pprTickGroup [] = panic "pprTickGroup"++data Tick  -- See Note [Which transformations are innocuous]+  = PreInlineUnconditionally    Id+  | PostInlineUnconditionally   Id++  | UnfoldingDone               Id+  | RuleFired                   FastString      -- Rule name++  | LetFloatFromLet+  | EtaExpansion                Id      -- LHS binder+  | EtaReduction                Id      -- Binder on outer lambda+  | BetaReduction               Id      -- Lambda binder+++  | CaseOfCase                  Id      -- Bndr on *inner* case+  | KnownBranch                 Id      -- Case binder+  | CaseMerge                   Id      -- Binder on outer case+  | AltMerge                    Id      -- Case binder+  | CaseElim                    Id      -- Case binder+  | CaseIdentity                Id      -- Case binder+  | FillInCaseDefault           Id      -- Case binder++  | SimplifierDone              -- Ticked at each iteration of the simplifier++instance Outputable Tick where+  ppr tick = text (tickString tick) <+> pprTickCts tick++instance Eq Tick where+  a == b = case a `cmpTick` b of+           EQ -> True+           _ -> False++instance Ord Tick where+  compare = cmpTick++tickToTag :: Tick -> Int+tickToTag (PreInlineUnconditionally _)  = 0+tickToTag (PostInlineUnconditionally _) = 1+tickToTag (UnfoldingDone _)             = 2+tickToTag (RuleFired _)                 = 3+tickToTag LetFloatFromLet               = 4+tickToTag (EtaExpansion _)              = 5+tickToTag (EtaReduction _)              = 6+tickToTag (BetaReduction _)             = 7+tickToTag (CaseOfCase _)                = 8+tickToTag (KnownBranch _)               = 9+tickToTag (CaseMerge _)                 = 10+tickToTag (CaseElim _)                  = 11+tickToTag (CaseIdentity _)              = 12+tickToTag (FillInCaseDefault _)         = 13+tickToTag SimplifierDone                = 16+tickToTag (AltMerge _)                  = 17++tickString :: Tick -> String+tickString (PreInlineUnconditionally _) = "PreInlineUnconditionally"+tickString (PostInlineUnconditionally _)= "PostInlineUnconditionally"+tickString (UnfoldingDone _)            = "UnfoldingDone"+tickString (RuleFired _)                = "RuleFired"+tickString LetFloatFromLet              = "LetFloatFromLet"+tickString (EtaExpansion _)             = "EtaExpansion"+tickString (EtaReduction _)             = "EtaReduction"+tickString (BetaReduction _)            = "BetaReduction"+tickString (CaseOfCase _)               = "CaseOfCase"+tickString (KnownBranch _)              = "KnownBranch"+tickString (CaseMerge _)                = "CaseMerge"+tickString (AltMerge _)                 = "AltMerge"+tickString (CaseElim _)                 = "CaseElim"+tickString (CaseIdentity _)             = "CaseIdentity"+tickString (FillInCaseDefault _)        = "FillInCaseDefault"+tickString SimplifierDone               = "SimplifierDone"++pprTickCts :: Tick -> SDoc+pprTickCts (PreInlineUnconditionally v) = ppr v+pprTickCts (PostInlineUnconditionally v)= ppr v+pprTickCts (UnfoldingDone v)            = ppr v+pprTickCts (RuleFired v)                = ppr v+pprTickCts LetFloatFromLet              = Outputable.empty+pprTickCts (EtaExpansion v)             = ppr v+pprTickCts (EtaReduction v)             = ppr v+pprTickCts (BetaReduction v)            = ppr v+pprTickCts (CaseOfCase v)               = ppr v+pprTickCts (KnownBranch v)              = ppr v+pprTickCts (CaseMerge v)                = ppr v+pprTickCts (AltMerge v)                 = ppr v+pprTickCts (CaseElim v)                 = ppr v+pprTickCts (CaseIdentity v)             = ppr v+pprTickCts (FillInCaseDefault v)        = ppr v+pprTickCts _                            = Outputable.empty++cmpTick :: Tick -> Tick -> Ordering+cmpTick a b = case (tickToTag a `compare` tickToTag b) of+                GT -> GT+                EQ -> cmpEqTick a b+                LT -> LT++cmpEqTick :: Tick -> Tick -> Ordering+cmpEqTick (PreInlineUnconditionally a)  (PreInlineUnconditionally b)    = a `compare` b+cmpEqTick (PostInlineUnconditionally a) (PostInlineUnconditionally b)   = a `compare` b+cmpEqTick (UnfoldingDone a)             (UnfoldingDone b)               = a `compare` b+cmpEqTick (RuleFired a)                 (RuleFired b)                   = a `compare` b+cmpEqTick (EtaExpansion a)              (EtaExpansion b)                = a `compare` b+cmpEqTick (EtaReduction a)              (EtaReduction b)                = a `compare` b+cmpEqTick (BetaReduction a)             (BetaReduction b)               = a `compare` b+cmpEqTick (CaseOfCase a)                (CaseOfCase b)                  = a `compare` b+cmpEqTick (KnownBranch a)               (KnownBranch b)                 = a `compare` b+cmpEqTick (CaseMerge a)                 (CaseMerge b)                   = a `compare` b+cmpEqTick (AltMerge a)                  (AltMerge b)                    = a `compare` b+cmpEqTick (CaseElim a)                  (CaseElim b)                    = a `compare` b+cmpEqTick (CaseIdentity a)              (CaseIdentity b)                = a `compare` b+cmpEqTick (FillInCaseDefault a)         (FillInCaseDefault b)           = a `compare` b+cmpEqTick _                             _                               = EQ++{-+************************************************************************+*                                                                      *+             Monad and carried data structure definitions+*                                                                      *+************************************************************************+-}++data CoreReader = CoreReader {+        cr_hsc_env             :: HscEnv,+        cr_rule_base           :: RuleBase,+        cr_module              :: Module,+        cr_print_unqual        :: PrintUnqualified,+        cr_loc                 :: SrcSpan,   -- Use this for log/error messages so they+                                             -- are at least tagged with the right source file+        cr_visible_orphan_mods :: !ModuleSet,+        cr_uniq_mask           :: !Char      -- Mask for creating unique values+}++-- Note: CoreWriter used to be defined with data, rather than newtype.  If it+-- is defined that way again, the cw_simpl_count field, at least, must be+-- strict to avoid a space leak (#7702).+newtype CoreWriter = CoreWriter {+        cw_simpl_count :: SimplCount+}++emptyWriter :: DynFlags -> CoreWriter+emptyWriter dflags = CoreWriter {+        cw_simpl_count = zeroSimplCount dflags+    }++plusWriter :: CoreWriter -> CoreWriter -> CoreWriter+plusWriter w1 w2 = CoreWriter {+        cw_simpl_count = (cw_simpl_count w1) `plusSimplCount` (cw_simpl_count w2)+    }++type CoreIOEnv = IOEnv CoreReader++-- | The monad used by Core-to-Core passes to register simplification statistics.+--  Also used to have common state (in the form of UniqueSupply) for generating Uniques.+newtype CoreM a = CoreM { unCoreM :: CoreIOEnv (a, CoreWriter) }+    deriving (Functor)++instance Monad CoreM where+    mx >>= f = CoreM $ do+            (x, w1) <- unCoreM mx+            (y, w2) <- unCoreM (f x)+            let w = w1 `plusWriter` w2+            return $ seq w (y, w)+            -- forcing w before building the tuple avoids a space leak+            -- (#7702)++instance Applicative CoreM where+    pure x = CoreM $ nop x+    (<*>) = ap+    m *> k = m >>= \_ -> k++instance Alternative CoreM where+    empty   = CoreM Control.Applicative.empty+    m <|> n = CoreM (unCoreM m <|> unCoreM n)++instance MonadPlus CoreM++instance MonadUnique CoreM where+    getUniqueSupplyM = do+        mask <- read cr_uniq_mask+        liftIO $! mkSplitUniqSupply mask++    getUniqueM = do+        mask <- read cr_uniq_mask+        liftIO $! uniqFromMask mask++runCoreM :: HscEnv+         -> RuleBase+         -> Char -- ^ Mask+         -> Module+         -> ModuleSet+         -> PrintUnqualified+         -> SrcSpan+         -> CoreM a+         -> IO (a, SimplCount)+runCoreM hsc_env rule_base mask mod orph_imps print_unqual loc m+  = liftM extract $ runIOEnv reader $ unCoreM m+  where+    reader = CoreReader {+            cr_hsc_env = hsc_env,+            cr_rule_base = rule_base,+            cr_module = mod,+            cr_visible_orphan_mods = orph_imps,+            cr_print_unqual = print_unqual,+            cr_loc = loc,+            cr_uniq_mask = mask+        }++    extract :: (a, CoreWriter) -> (a, SimplCount)+    extract (value, writer) = (value, cw_simpl_count writer)++{-+************************************************************************+*                                                                      *+             Core combinators, not exported+*                                                                      *+************************************************************************+-}++nop :: a -> CoreIOEnv (a, CoreWriter)+nop x = do+    r <- getEnv+    return (x, emptyWriter $ (hsc_dflags . cr_hsc_env) r)++read :: (CoreReader -> a) -> CoreM a+read f = CoreM $ getEnv >>= (\r -> nop (f r))++write :: CoreWriter -> CoreM ()+write w = CoreM $ return ((), w)++-- \subsection{Lifting IO into the monad}++-- | Lift an 'IOEnv' operation into 'CoreM'+liftIOEnv :: CoreIOEnv a -> CoreM a+liftIOEnv mx = CoreM (mx >>= (\x -> nop x))++instance MonadIO CoreM where+    liftIO = liftIOEnv . IOEnv.liftIO++-- | Lift an 'IO' operation into 'CoreM' while consuming its 'SimplCount'+liftIOWithCount :: IO (SimplCount, a) -> CoreM a+liftIOWithCount what = liftIO what >>= (\(count, x) -> addSimplCount count >> return x)++{-+************************************************************************+*                                                                      *+             Reader, writer and state accessors+*                                                                      *+************************************************************************+-}++getHscEnv :: CoreM HscEnv+getHscEnv = read cr_hsc_env++getRuleBase :: CoreM RuleBase+getRuleBase = read cr_rule_base++getVisibleOrphanMods :: CoreM ModuleSet+getVisibleOrphanMods = read cr_visible_orphan_mods++getPrintUnqualified :: CoreM PrintUnqualified+getPrintUnqualified = read cr_print_unqual++getSrcSpanM :: CoreM SrcSpan+getSrcSpanM = read cr_loc++addSimplCount :: SimplCount -> CoreM ()+addSimplCount count = write (CoreWriter { cw_simpl_count = count })++getUniqMask :: CoreM Char+getUniqMask = read cr_uniq_mask++-- Convenience accessors for useful fields of HscEnv++instance HasDynFlags CoreM where+    getDynFlags = fmap hsc_dflags getHscEnv++instance HasModule CoreM where+    getModule = read cr_module++getPackageFamInstEnv :: CoreM PackageFamInstEnv+getPackageFamInstEnv = do+    hsc_env <- getHscEnv+    eps <- liftIO $ hscEPS hsc_env+    return $ eps_fam_inst_env eps++{-+************************************************************************+*                                                                      *+             Dealing with annotations+*                                                                      *+************************************************************************+-}++-- | Get all annotations of a given type. This happens lazily, that is+-- no deserialization will take place until the [a] is actually demanded and+-- the [a] can also be empty (the UniqFM is not filtered).+--+-- This should be done once at the start of a Core-to-Core pass that uses+-- annotations.+--+-- See Note [Annotations]+getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv [a], NameEnv [a])+getAnnotations deserialize guts = do+     hsc_env <- getHscEnv+     ann_env <- liftIO $ prepareAnnotations hsc_env (Just guts)+     return (deserializeAnns deserialize ann_env)++-- | Get at most one annotation of a given type per annotatable item.+getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv a, NameEnv a)+getFirstAnnotations deserialize guts+  = bimap mod name <$> getAnnotations deserialize guts+  where+    mod = mapModuleEnv head . filterModuleEnv (const $ not . null)+    name = mapNameEnv head . filterNameEnv (not . null)++{-+Note [Annotations]+~~~~~~~~~~~~~~~~~~+A Core-to-Core pass that wants to make use of annotations calls+getAnnotations or getFirstAnnotations at the beginning to obtain a UniqFM with+annotations of a specific type. This produces all annotations from interface+files read so far. However, annotations from interface files read during the+pass will not be visible until getAnnotations is called again. This is similar+to how rules work and probably isn't too bad.++The current implementation could be optimised a bit: when looking up+annotations for a thing from the HomePackageTable, we could search directly in+the module where the thing is defined rather than building one UniqFM which+contains all annotations we know of. This would work because annotations can+only be given to things defined in the same module. However, since we would+only want to deserialise every annotation once, we would have to build a cache+for every module in the HTP. In the end, it's probably not worth it as long as+we aren't using annotations heavily.++************************************************************************+*                                                                      *+                Direct screen output+*                                                                      *+************************************************************************+-}++msg :: Severity -> WarnReason -> SDoc -> CoreM ()+msg sev reason doc+  = do { dflags <- getDynFlags+       ; loc    <- getSrcSpanM+       ; unqual <- getPrintUnqualified+       ; let sty = case sev of+                     SevError   -> err_sty+                     SevWarning -> err_sty+                     SevDump    -> dump_sty+                     _          -> user_sty+             err_sty  = mkErrStyle dflags unqual+             user_sty = mkUserStyle dflags unqual AllTheWay+             dump_sty = mkDumpStyle dflags unqual+       ; liftIO $ putLogMsg dflags reason sev loc sty doc }++-- | Output a String message to the screen+putMsgS :: String -> CoreM ()+putMsgS = putMsg . text++-- | Output a message to the screen+putMsg :: SDoc -> CoreM ()+putMsg = msg SevInfo NoReason++-- | Output an error to the screen. Does not cause the compiler to die.+errorMsgS :: String -> CoreM ()+errorMsgS = errorMsg . text++-- | Output an error to the screen. Does not cause the compiler to die.+errorMsg :: SDoc -> CoreM ()+errorMsg = msg SevError NoReason++warnMsg :: WarnReason -> SDoc -> CoreM ()+warnMsg = msg SevWarning++-- | Output a fatal error to the screen. Does not cause the compiler to die.+fatalErrorMsgS :: String -> CoreM ()+fatalErrorMsgS = fatalErrorMsg . text++-- | Output a fatal error to the screen. Does not cause the compiler to die.+fatalErrorMsg :: SDoc -> CoreM ()+fatalErrorMsg = msg SevFatal NoReason++-- | Output a string debugging message at verbosity level of @-v@ or higher+debugTraceMsgS :: String -> CoreM ()+debugTraceMsgS = debugTraceMsg . text++-- | Outputs a debugging message at verbosity level of @-v@ or higher+debugTraceMsg :: SDoc -> CoreM ()+debugTraceMsg = msg SevDump NoReason++-- | Show some labelled 'SDoc' if a particular flag is set or at a verbosity level of @-v -ddump-most@ or higher+dumpIfSet_dyn :: DumpFlag -> String -> DumpFormat -> SDoc -> CoreM ()+dumpIfSet_dyn flag str fmt doc+  = do { dflags <- getDynFlags+       ; unqual <- getPrintUnqualified+       ; when (dopt flag dflags) $ liftIO $ do+         let sty = mkDumpStyle dflags unqual+         dumpAction dflags sty (dumpOptionsFromFlag flag) str fmt doc }
+ compiler/GHC/Core/Opt/Monad.hs-boot view
@@ -0,0 +1,30 @@+-- Created this hs-boot file to remove circular dependencies from the use of+-- Plugins. Plugins needs CoreToDo and CoreM types to define core-to-core+-- transformations.+-- However GHC.Core.Opt.Monad does much more than defining these, and because Plugins are+-- activated in various modules, the imports become circular. To solve this I+-- extracted CoreToDo and CoreM into this file.+-- I needed to write the whole definition of these types, otherwise it created+-- a data-newtype conflict.++module GHC.Core.Opt.Monad ( CoreToDo, CoreM ) where++import GHC.Prelude++import GHC.Data.IOEnv ( IOEnv )++type CoreIOEnv = IOEnv CoreReader++data CoreReader++newtype CoreWriter = CoreWriter {+        cw_simpl_count :: SimplCount+}++data SimplCount++newtype CoreM a = CoreM { unCoreM :: CoreIOEnv (a, CoreWriter) }++instance Monad CoreM++data CoreToDo
+ compiler/GHC/Core/Opt/OccurAnal.hs view
@@ -0,0 +1,2971 @@+{-+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++************************************************************************+*                                                                      *+\section[OccurAnal]{Occurrence analysis pass}+*                                                                      *+************************************************************************++The occurrence analyser re-typechecks a core expression, returning a new+core expression with (hopefully) improved usage information.+-}++{-# LANGUAGE CPP, BangPatterns, MultiWayIf, ViewPatterns  #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}+module GHC.Core.Opt.OccurAnal ( occurAnalysePgm, occurAnalyseExpr ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Core+import GHC.Core.FVs+import GHC.Core.Utils   ( exprIsTrivial, isDefaultAlt, isExpandableApp,+                          stripTicksTopE, mkTicks )+import GHC.Core.Arity   ( joinRhsArity )+import GHC.Types.Id+import GHC.Types.Id.Info+import GHC.Types.Basic+import GHC.Unit.Module( Module )+import GHC.Core.Coercion+import GHC.Core.Type++import GHC.Types.Var.Set+import GHC.Types.Var.Env+import GHC.Types.Var+import GHC.Types.Demand ( argOneShots, argsOneShots )+import GHC.Data.Graph.Directed ( SCC(..), Node(..)+                               , stronglyConnCompFromEdgedVerticesUniq+                               , stronglyConnCompFromEdgedVerticesUniqR )+import GHC.Types.Unique+import GHC.Types.Unique.FM+import GHC.Types.Unique.Set+import GHC.Utils.Misc+import GHC.Data.Maybe( orElse, isJust )+import GHC.Utils.Outputable+import Data.List++{-+************************************************************************+*                                                                      *+    occurAnalysePgm, occurAnalyseExpr+*                                                                      *+************************************************************************++Here's the externally-callable interface:+-}++occurAnalysePgm :: Module         -- Used only in debug output+                -> (Id -> Bool)         -- Active unfoldings+                -> (Activation -> Bool) -- Active rules+                -> [CoreRule]+                -> CoreProgram -> CoreProgram+occurAnalysePgm this_mod active_unf active_rule imp_rules binds+  | isEmptyDetails final_usage+  = occ_anald_binds++  | otherwise   -- See Note [Glomming]+  = WARN( True, hang (text "Glomming in" <+> ppr this_mod <> colon)+                   2 (ppr final_usage ) )+    occ_anald_glommed_binds+  where+    init_env = initOccEnv { occ_rule_act = active_rule+                          , occ_unf_act  = active_unf }++    (final_usage, occ_anald_binds) = go init_env binds+    (_, occ_anald_glommed_binds)   = occAnalRecBind init_env TopLevel+                                                    imp_rule_edges+                                                    (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 = addManyOccs emptyDetails (rulesFreeVars imp_rules)+    -- The RULES declarations keep things alive!++    -- Note [Preventing loops due to imported functions rules]+    imp_rule_edges = foldr (plusVarEnv_C unionVarSet) emptyVarEnv+                            [ mapVarEnv (const maps_to) $+                                getUniqSet (exprFreeIds arg `delVarSetList` ru_bndrs imp_rule)+                            | imp_rule <- imp_rules+                            , not (isBuiltinRule imp_rule)  -- See Note [Plugin rules]+                            , let maps_to = exprFreeIds (ru_rhs imp_rule)+                                             `delVarSetList` ru_bndrs imp_rule+                            , arg <- ru_args imp_rule ]++    go :: OccEnv -> [CoreBind] -> (UsageDetails, [CoreBind])+    go _ []+        = (initial_uds, [])+    go env (bind:binds)+        = (final_usage, bind' ++ binds')+        where+           (bs_usage, binds')   = go env binds+           (final_usage, bind') = occAnalBind env TopLevel imp_rule_edges bind+                                              bs_usage++occurAnalyseExpr :: CoreExpr -> CoreExpr+-- Do occurrence analysis, and discard occurrence info returned+occurAnalyseExpr expr+  = snd (occAnal initOccEnv expr)++{- Note [Plugin rules]+~~~~~~~~~~~~~~~~~~~~~~+Conal Elliott (#11651) built a GHC plugin that added some+BuiltinRules (for imported Ids) to the mg_rules field of ModGuts, to+do some domain-specific transformations that could not be expressed+with an ordinary pattern-matching CoreRule.  But then we can't extract+the dependencies (in imp_rule_edges) from ru_rhs etc, because a+BuiltinRule doesn't have any of that stuff.++So we simply assume that BuiltinRules have no dependencies, and filter+them out from the imp_rule_edges comprehension.+-}++{-+************************************************************************+*                                                                      *+                Bindings+*                                                                      *+************************************************************************++Note [Recursive bindings: the grand plan]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we come across a binding group+  Rec { x1 = r1; ...; xn = rn }+we treat it like this (occAnalRecBind):++1. Occurrence-analyse each right hand side, and build a+   "Details" for each binding to capture the results.++   Wrap the details in a Node (details, node-id, dep-node-ids),+   where node-id is just the unique of the binder, and+   dep-node-ids lists all binders on which this binding depends.+   We'll call these the "scope edges".+   See Note [Forming the Rec groups].++   All this is done by makeNode.++2. Do SCC-analysis on these Nodes.  Each SCC will become a new Rec or+   NonRec.  The key property is that every free variable of a binding+   is accounted for by the scope edges, so that when we are done+   everything is still in scope.++3. For each Cyclic SCC of the scope-edge SCC-analysis in (2), we+   identify suitable loop-breakers to ensure that inlining terminates.+   This is done by occAnalRec.++4. To do so we form a new set of Nodes, with the same details, but+   different edges, the "loop-breaker nodes". The loop-breaker nodes+   have both more and fewer dependencies than the scope edges+   (see Note [Choosing loop breakers])++   More edges: if f calls g, and g has an active rule that mentions h+               then we add an edge from f -> h++   Fewer edges: we only include dependencies on active rules, on rule+                RHSs (not LHSs) and if there is an INLINE pragma only+                on the stable unfolding (and vice versa).  The scope+                edges must be much more inclusive.++5.  The "weak fvs" of a node are, by definition:+       the scope fvs - the loop-breaker fvs+    See Note [Weak loop breakers], and the nd_weak field of Details++6.  Having formed the loop-breaker nodes++Note [Dead code]+~~~~~~~~~~~~~~~~+Dropping dead code for a cyclic Strongly Connected Component is done+in a very simple way:++        the entire SCC is dropped if none of its binders are mentioned+        in the body; otherwise the whole thing is kept.++The key observation is that dead code elimination happens after+dependency analysis: so 'occAnalBind' processes SCCs instead of the+original term's binding groups.++Thus 'occAnalBind' does indeed drop 'f' in an example like++        letrec f = ...g...+               g = ...(...g...)...+        in+           ...g...++when 'g' no longer uses 'f' at all (eg 'f' does not occur in a RULE in+'g'). 'occAnalBind' first consumes 'CyclicSCC g' and then it consumes+'AcyclicSCC f', where 'body_usage' won't contain 'f'.++------------------------------------------------------------+Note [Forming Rec groups]+~~~~~~~~~~~~~~~~~~~~~~~~~+We put bindings {f = ef; g = eg } in a Rec group if "f uses g"+and "g uses f", no matter how indirectly.  We do a SCC analysis+with an edge f -> g if "f uses g".++More precisely, "f uses g" iff g should be in scope wherever f is.+That is, g is free in:+  a) the rhs 'ef'+  b) or the RHS of a rule for f (Note [Rules are extra RHSs])+  c) or the LHS or a rule for f (Note [Rule dependency info])++These conditions apply regardless of the activation of the RULE (eg it might be+inactive in this phase but become active later).  Once a Rec is broken up+it can never be put back together, so we must be conservative.++The principle is that, regardless of rule firings, every variable is+always in scope.++  * Note [Rules are extra RHSs]+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~+    A RULE for 'f' is like an extra RHS for 'f'. That way the "parent"+    keeps the specialised "children" alive.  If the parent dies+    (because it isn't referenced any more), then the children will die+    too (unless they are already referenced directly).++    To that end, we build a Rec group for each cyclic strongly+    connected component,+        *treating f's rules as extra RHSs for 'f'*.+    More concretely, the SCC analysis runs on a graph with an edge+    from f -> g iff g is mentioned in+        (a) f's rhs+        (b) f's RULES+    These are rec_edges.++    Under (b) we include variables free in *either* LHS *or* RHS of+    the rule.  The former might seems silly, but see Note [Rule+    dependency info].  So in Example [eftInt], eftInt and eftIntFB+    will be put in the same Rec, even though their 'main' RHSs are+    both non-recursive.++  * Note [Rule dependency info]+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~+    The VarSet in a RuleInfo is used for dependency analysis in the+    occurrence analyser.  We must track free vars in *both* lhs and rhs.+    Hence use of idRuleVars, rather than idRuleRhsVars in occAnalBind.+    Why both? Consider+        x = y+        RULE f x = v+4+    Then if we substitute y for x, we'd better do so in the+    rule's LHS too, so we'd better ensure the RULE appears to mention 'x'+    as well as 'v'++  * Note [Rules are visible in their own rec group]+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+    We want the rules for 'f' to be visible in f's right-hand side.+    And we'd like them to be visible in other functions in f's Rec+    group.  E.g. in Note [Specialisation rules] we want f' rule+    to be visible in both f's RHS, and fs's RHS.++    This means that we must simplify the RULEs first, before looking+    at any of the definitions.  This is done by Simplify.simplRecBind,+    when it calls addLetIdInfo.++------------------------------------------------------------+Note [Choosing loop breakers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Loop breaking is surprisingly subtle.  First read the section 4 of+"Secrets of the GHC inliner".  This describes our basic plan.+We avoid infinite inlinings by choosing loop breakers, and+ensuring that a loop breaker cuts each loop.++See also Note [Inlining and hs-boot files] in GHC.Core.ToIface, which+deals with a closely related source of infinite loops.++Fundamentally, we do SCC analysis on a graph.  For each recursive+group we choose a loop breaker, delete all edges to that node,+re-analyse the SCC, and iterate.++But what is the graph?  NOT the same graph as was used for Note+[Forming Rec groups]!  In particular, a RULE is like an equation for+'f' that is *always* inlined if it is applicable.  We do *not* disable+rules for loop-breakers.  It's up to whoever makes the rules to make+sure that the rules themselves always terminate.  See Note [Rules for+recursive functions] in GHC.Core.Opt.Simplify++Hence, if+    f's RHS (or its INLINE template if it has one) mentions g, and+    g has a RULE that mentions h, and+    h has a RULE that mentions f++then we *must* choose f to be a loop breaker.  Example: see Note+[Specialisation rules].++In general, take the free variables of f's RHS, and augment it with+all the variables reachable by RULES from those starting points.  That+is the whole reason for computing rule_fv_env in occAnalBind.  (Of+course we only consider free vars that are also binders in this Rec+group.)  See also Note [Finding rule RHS free vars]++Note that when we compute this rule_fv_env, we only consider variables+free in the *RHS* of the rule, in contrast to the way we build the+Rec group in the first place (Note [Rule dependency info])++Note that if 'g' has RHS that mentions 'w', we should add w to+g's loop-breaker edges.  More concretely there is an edge from f -> g+iff+        (a) g is mentioned in f's RHS `xor` f's INLINE rhs+            (see Note [Inline rules])+        (b) or h is mentioned in f's RHS, and+            g appears in the RHS of an active RULE of h+            or a transitive sequence of active rules starting with h++Why "active rules"?  See Note [Finding rule RHS free vars]++Note that in Example [eftInt], *neither* eftInt *nor* eftIntFB is+chosen as a loop breaker, because their RHSs don't mention each other.+And indeed both can be inlined safely.++Note again that the edges of the graph we use for computing loop breakers+are not the same as the edges we use for computing the Rec blocks.+That's why we compute++- rec_edges          for the Rec block analysis+- loop_breaker_nodes for the loop breaker analysis++  * Note [Finding rule RHS free vars]+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+    Consider this real example from Data Parallel Haskell+         tagZero :: Array Int -> Array Tag+         {-# INLINE [1] tagZeroes #-}+         tagZero xs = pmap (\x -> fromBool (x==0)) xs++         {-# RULES "tagZero" [~1] forall xs n.+             pmap fromBool <blah blah> = tagZero xs #-}+    So tagZero's RHS mentions pmap, and pmap's RULE mentions tagZero.+    However, tagZero can only be inlined in phase 1 and later, while+    the RULE is only active *before* phase 1.  So there's no problem.++    To make this work, we look for the RHS free vars only for+    *active* rules. That's the reason for the occ_rule_act field+    of the OccEnv.++  * Note [Weak loop breakers]+    ~~~~~~~~~~~~~~~~~~~~~~~~~+    There is a last nasty wrinkle.  Suppose we have++        Rec { f = f_rhs+              RULE f [] = g++              h = h_rhs+              g = h+              ...more...+        }++    Remember that we simplify the RULES before any RHS (see Note+    [Rules are visible in their own rec group] above).++    So we must *not* postInlineUnconditionally 'g', even though+    its RHS turns out to be trivial.  (I'm assuming that 'g' is+    not chosen as a loop breaker.)  Why not?  Because then we+    drop the binding for 'g', which leaves it out of scope in the+    RULE!++    Here's a somewhat different example of the same thing+        Rec { g = h+            ; h = ...f...+            ; f = f_rhs+              RULE f [] = g }+    Here the RULE is "below" g, but we *still* can't postInlineUnconditionally+    g, because the RULE for f is active throughout.  So the RHS of h+    might rewrite to     h = ...g...+    So g must remain in scope in the output program!++    We "solve" this by:++        Make g a "weak" loop breaker (OccInfo = IAmLoopBreaker True)+        iff g is a "missing free variable" of the Rec group++    A "missing free variable" x is one that is mentioned in an RHS or+    INLINE or RULE of a binding in the Rec group, but where the+    dependency on x may not show up in the loop_breaker_nodes (see+    note [Choosing loop breakers} above).++    A normal "strong" loop breaker has IAmLoopBreaker False.  So++                                    Inline  postInlineUnconditionally+   strong   IAmLoopBreaker False    no      no+   weak     IAmLoopBreaker True     yes     no+            other                   yes     yes++    The **sole** reason for this kind of loop breaker is so that+    postInlineUnconditionally does not fire.  Ugh.  (Typically it'll+    inline via the usual callSiteInline stuff, so it'll be dead in the+    next pass, so the main Ugh is the tiresome complication.)++Note [Rules for imported functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this+   f = /\a. B.g a+   RULE B.g Int = 1 + f Int+Note that+  * The RULE is for an imported function.+  * f is non-recursive+Now we+can get+   f Int --> B.g Int      Inlining f+         --> 1 + f Int    Firing RULE+and so the simplifier goes into an infinite loop. This+would not happen if the RULE was for a local function,+because we keep track of dependencies through rules.  But+that is pretty much impossible to do for imported Ids.  Suppose+f's definition had been+   f = /\a. C.h a+where (by some long and devious process), C.h eventually inlines to+B.g.  We could only spot such loops by exhaustively following+unfoldings of C.h etc, in case we reach B.g, and hence (via the RULE)+f.++Note that RULES for imported functions are important in practice; they+occur a lot in the libraries.++We regard this potential infinite loop as a *programmer* error.+It's up the programmer not to write silly rules like+     RULE f x = f x+and the example above is just a more complicated version.++Note [Preventing loops due to imported functions rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider:+  import GHC.Base (foldr)++  {-# RULES "filterList" forall p. foldr (filterFB (:) p) [] = filter p #-}+  filter p xs = build (\c n -> foldr (filterFB c p) n xs)+  filterFB c p = ...++  f = filter p xs++Note that filter is not a loop-breaker, so what happens is:+  f =          filter p xs+    = {inline} build (\c n -> foldr (filterFB c p) n xs)+    = {inline} foldr (filterFB (:) p) [] xs+    = {RULE}   filter p xs++We are in an infinite loop.++A more elaborate example (that I actually saw in practice when I went to+mark GHC.List.filter as INLINABLE) is as follows. Say I have this module:+  {-# LANGUAGE RankNTypes #-}+  module GHCList where++  import Prelude hiding (filter)+  import GHC.Base (build)++  {-# INLINABLE filter #-}+  filter :: (a -> Bool) -> [a] -> [a]+  filter p [] = []+  filter p (x:xs) = if p x then x : filter p xs else filter p xs++  {-# NOINLINE [0] filterFB #-}+  filterFB :: (a -> b -> b) -> (a -> Bool) -> a -> b -> b+  filterFB c p x r | p x       = x `c` r+                   | otherwise = r++  {-# RULES+  "filter"     [~1] forall p xs.  filter p xs = build (\c n -> foldr+  (filterFB c p) n xs)+  "filterList" [1]  forall p.     foldr (filterFB (:) p) [] = filter p+   #-}++Then (because RULES are applied inside INLINABLE unfoldings, but inlinings+are not), the unfolding given to "filter" in the interface file will be:+  filter p []     = []+  filter p (x:xs) = if p x then x : build (\c n -> foldr (filterFB c p) n xs)+                           else     build (\c n -> foldr (filterFB c p) n xs++Note that because this unfolding does not mention "filter", filter is not+marked as a strong loop breaker. Therefore at a use site in another module:+  filter p xs+    = {inline}+      case xs of []     -> []+                 (x:xs) -> if p x then x : build (\c n -> foldr (filterFB c p) n xs)+                                  else     build (\c n -> foldr (filterFB c p) n xs)++  build (\c n -> foldr (filterFB c p) n xs)+    = {inline} foldr (filterFB (:) p) [] xs+    = {RULE}   filter p xs++And we are in an infinite loop again, except that this time the loop is producing an+infinitely large *term* (an unrolling of filter) and so the simplifier finally+dies with "ticks exhausted"++Because of this problem, we make a small change in the occurrence analyser+designed to mark functions like "filter" as strong loop breakers on the basis that:+  1. The RHS of filter mentions the local function "filterFB"+  2. We have a rule which mentions "filterFB" on the LHS and "filter" on the RHS++So for each RULE for an *imported* function we are going to add+dependency edges between the *local* FVS of the rule LHS and the+*local* FVS of the rule RHS. We don't do anything special for RULES on+local functions because the standard occurrence analysis stuff is+pretty good at getting loop-breakerness correct there.++It is important to note that even with this extra hack we aren't always going to get+things right. For example, it might be that the rule LHS mentions an imported Id,+and another module has a RULE that can rewrite that imported Id to one of our local+Ids.++Note [Specialising imported functions] (referred to from Specialise)+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+BUT for *automatically-generated* rules, the programmer can't be+responsible for the "programmer error" in Note [Rules for imported+functions].  In particular, consider specialising a recursive function+defined in another module.  If we specialise a recursive function B.g,+we get+         g_spec = .....(B.g Int).....+         RULE B.g Int = g_spec+Here, g_spec doesn't look recursive, but when the rule fires, it+becomes so.  And if B.g was mutually recursive, the loop might+not be as obvious as it is here.++To avoid this,+ * When specialising a function that is a loop breaker,+   give a NOINLINE pragma to the specialised function++Note [Glomming]+~~~~~~~~~~~~~~~+RULES for imported Ids can make something at the top refer to something at the bottom:+        f = \x -> B.g (q x)+        h = \y -> 3++        RULE:  B.g (q x) = h x++Applying this rule makes f refer to h, although f doesn't appear to+depend on h.  (And, as in Note [Rules for imported functions], the+dependency might be more indirect. For example, f might mention C.t+rather than B.g, where C.t eventually inlines to B.g.)++NOTICE that this cannot happen for rules whose head is a+locally-defined function, because we accurately track dependencies+through RULES.  It only happens for rules whose head is an imported+function (B.g in the example above).++Solution:+  - When simplifying, bring all top level identifiers into+    scope at the start, ignoring the Rec/NonRec structure, so+    that when 'h' pops up in f's rhs, we find it in the in-scope set+    (as the simplifier generally expects). This happens in simplTopBinds.++  - In the occurrence analyser, if there are any out-of-scope+    occurrences that pop out of the top, which will happen after+    firing the rule:      f = \x -> h x+                          h = \y -> 3+    then just glom all the bindings into a single Rec, so that+    the *next* iteration of the occurrence analyser will sort+    them all out.   This part happens in occurAnalysePgm.++------------------------------------------------------------+Note [Inline rules]+~~~~~~~~~~~~~~~~~~~+None of the above stuff about RULES applies to Inline Rules,+stored in a CoreUnfolding.  The unfolding, if any, is simplified+at the same time as the regular RHS of the function (ie *not* like+Note [Rules are visible in their own rec group]), so it should be+treated *exactly* like an extra RHS.++Or, rather, when computing loop-breaker edges,+  * If f has an INLINE pragma, and it is active, we treat the+    INLINE rhs as f's rhs+  * If it's inactive, we treat f as having no rhs+  * If it has no INLINE pragma, we look at f's actual rhs+++There is a danger that we'll be sub-optimal if we see this+     f = ...f...+     [INLINE f = ..no f...]+where f is recursive, but the INLINE is not. This can just about+happen with a sufficiently odd set of rules; eg++        foo :: Int -> Int+        {-# INLINE [1] foo #-}+        foo x = x+1++        bar :: Int -> Int+        {-# INLINE [1] bar #-}+        bar x = foo x + 1++        {-# RULES "foo" [~1] forall x. foo x = bar x #-}++Here the RULE makes bar recursive; but it's INLINE pragma remains+non-recursive. It's tempting to then say that 'bar' should not be+a loop breaker, but an attempt to do so goes wrong in two ways:+   a) We may get+         $df = ...$cfoo...+         $cfoo = ...$df....+         [INLINE $cfoo = ...no-$df...]+      But we want $cfoo to depend on $df explicitly so that we+      put the bindings in the right order to inline $df in $cfoo+      and perhaps break the loop altogether.  (Maybe this+   b)+++Example [eftInt]+~~~~~~~~~~~~~~~+Example (from GHC.Enum):++  eftInt :: Int# -> Int# -> [Int]+  eftInt x y = ...(non-recursive)...++  {-# INLINE [0] eftIntFB #-}+  eftIntFB :: (Int -> r -> r) -> r -> Int# -> Int# -> r+  eftIntFB c n x y = ...(non-recursive)...++  {-# RULES+  "eftInt"  [~1] forall x y. eftInt x y = build (\ c n -> eftIntFB c n x y)+  "eftIntList"  [1] eftIntFB  (:) [] = eftInt+   #-}++Note [Specialisation rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this group, which is typical of what SpecConstr builds:++   fs a = ....f (C a)....+   f  x = ....f (C a)....+   {-# RULE f (C a) = fs a #-}++So 'f' and 'fs' are in the same Rec group (since f refers to fs via its RULE).++But watch out!  If 'fs' is not chosen as a loop breaker, we may get an infinite loop:+  - the RULE is applied in f's RHS (see Note [Self-recursive rules] in GHC.Core.Opt.Simplify+  - fs is inlined (say it's small)+  - now there's another opportunity to apply the RULE++This showed up when compiling Control.Concurrent.Chan.getChanContents.++------------------------------------------------------------+Note [Finding join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~+It's the occurrence analyser's job to find bindings that we can turn into join+points, but it doesn't perform that transformation right away. Rather, it marks+the eligible bindings as part of their occurrence data, leaving it to the+simplifier (or to simpleOptPgm) to actually change the binder's 'IdDetails'.+The simplifier then eta-expands the RHS if needed and then updates the+occurrence sites. Dividing the work this way means that the occurrence analyser+still only takes one pass, yet one can always tell the difference between a+function call and a jump by looking at the occurrence (because the same pass+changes the 'IdDetails' and propagates the binders to their occurrence sites).++To track potential join points, we use the 'occ_tail' field of OccInfo. A value+of `AlwaysTailCalled n` indicates that every occurrence of the variable is a+tail call with `n` arguments (counting both value and type arguments). Otherwise+'occ_tail' will be 'NoTailCallInfo'. The tail call info flows bottom-up with the+rest of 'OccInfo' until it goes on the binder.++Note [Join points and unfoldings/rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+   let j2 y = blah+   let j x = j2 (x+x)+       {-# INLINE [2] j #-}+   in case e of { A -> j 1; B -> ...; C -> j 2 }++Before j is inlined, we'll have occurrences of j2 in+both j's RHS and in its stable unfolding.  We want to discover+j2 as a join point.  So we must do the adjustRhsUsage thing+on j's RHS.  That's why we pass mb_join_arity to calcUnfolding.++Aame with rules. Suppose we have:++  let j :: Int -> Int+      j y = 2 * y+  let k :: Int -> Int -> Int+      {-# RULES "SPEC k 0" k 0 y = j y #-}+      k x y = x + 2 * y+  in case e of { A -> k 1 2; B -> k 3 5; C -> blah }++We identify k as a join point, and we want j to be a join point too.+Without the RULE it would be, and we don't want the RULE to mess it+up.  So provided the join-point arity of k matches the args of the+rule we can allow the tail-cal info from the RHS of the rule to+propagate.++* Wrinkle for Rec case. In the recursive case we don't know the+  join-point arity in advance, when calling occAnalUnfolding and+  occAnalRules.  (See makeNode.)  We don't want to pass Nothing,+  because then a recursive joinrec might lose its join-poin-hood+  when SpecConstr adds a RULE.  So we just make do with the+  *current* join-poin-hood, stored in the Id.++  In the non-recursive case things are simple: see occAnalNonRecBind++* Wrinkle for RULES.  Suppose the example was a bit different:+      let j :: Int -> Int+          j y = 2 * y+          k :: Int -> Int -> Int+          {-# RULES "SPEC k 0" k 0 = j #-}+          k x y = x + 2 * y+      in ...+  If we eta-expanded the rule all woudl be well, but as it stands the+  one arg of the rule don't match the join-point arity of 2.++  Conceivably we could notice that a potential join point would have+  an "undersaturated" rule and account for it. This would mean we+  could make something that's been specialised a join point, for+  instance. But local bindings are rarely specialised, and being+  overly cautious about rules only costs us anything when, for some `j`:++  * Before specialisation, `j` has non-tail calls, so it can't be a join point.+  * During specialisation, `j` gets specialised and thus acquires rules.+  * Sometime afterward, the non-tail calls to `j` disappear (as dead code, say),+    and so now `j` *could* become a join point.++  This appears to be very rare in practice. TODO Perhaps we should gather+  statistics to be sure.++------------------------------------------------------------+Note [Adjusting right-hand sides]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There's a bit of a dance we need to do after analysing a lambda expression or+a right-hand side. In particular, we need to++  a) call 'markAllInsideLam' *unless* the binding is for a thunk, a one-shot+     lambda, or a non-recursive join point; and+  b) call 'markAllNonTail' *unless* the binding is for a join point.++Some examples, with how the free occurrences in e (assumed not to be a value+lambda) get marked:++                             inside lam    non-tail-called+  ------------------------------------------------------------+  let x = e                  No            Yes+  let f = \x -> e            Yes           Yes+  let f = \x{OneShot} -> e   No            Yes+  \x -> e                    Yes           Yes+  join j x = e               No            No+  joinrec j x = e            Yes           No++There are a few other caveats; most importantly, if we're marking a binding as+'AlwaysTailCalled', it's *going* to be a join point, so we treat it as one so+that the effect cascades properly. Consequently, at the time the RHS is+analysed, we won't know what adjustments to make; thus 'occAnalLamOrRhs' must+return the unadjusted 'UsageDetails', to be adjusted by 'adjustRhsUsage' once+join-point-hood has been decided.++Thus the overall sequence taking place in 'occAnalNonRecBind' and+'occAnalRecBind' is as follows:++  1. Call 'occAnalLamOrRhs' to find usage information for the RHS.+  2. Call 'tagNonRecBinder' or 'tagRecBinders', which decides whether to make+     the binding a join point.+  3. Call 'adjustRhsUsage' accordingly. (Done as part of 'tagRecBinders' when+     recursive.)++(In the recursive case, this logic is spread between 'makeNode' and+'occAnalRec'.)+-}++------------------------------------------------------------------+--                 occAnalBind+------------------------------------------------------------------++occAnalBind :: OccEnv           -- The incoming OccEnv+            -> TopLevelFlag+            -> ImpRuleEdges+            -> CoreBind+            -> UsageDetails             -- Usage details of scope+            -> (UsageDetails,           -- Of the whole let(rec)+                [CoreBind])++occAnalBind env lvl top_env (NonRec binder rhs) body_usage+  = occAnalNonRecBind env lvl top_env binder rhs body_usage+occAnalBind env lvl top_env (Rec pairs) body_usage+  = occAnalRecBind env lvl top_env pairs body_usage++-----------------+occAnalNonRecBind :: OccEnv -> TopLevelFlag -> ImpRuleEdges -> Var -> CoreExpr+                  -> UsageDetails -> (UsageDetails, [CoreBind])+occAnalNonRecBind env lvl imp_rule_edges bndr rhs body_usage+  | isTyVar bndr      -- A type let; we don't gather usage info+  = (body_usage, [NonRec bndr rhs])++  | not (bndr `usedIn` body_usage)    -- It's not mentioned+  = (body_usage, [])++  | otherwise                   -- It's mentioned in the body+  = (body_usage' `andUDs` rhs_usage4, [NonRec final_bndr rhs'])+  where+    (body_usage', tagged_bndr) = tagNonRecBinder lvl body_usage bndr+    occ                        = idOccInfo tagged_bndr++    -- Get the join info from the *new* decision+    -- See Note [Join points and unfoldings/rules]+    mb_join_arity = willBeJoinId_maybe tagged_bndr+    is_join_point = isJust mb_join_arity++    final_bndr = tagged_bndr `setIdUnfolding` unf'+                             `setIdSpecialisation` mkRuleInfo rules'++    env1 | is_join_point    = env  -- See Note [Join point RHSs]+         | certainly_inline = env  -- See Note [Cascading inlines]+         | otherwise        = rhsCtxt env++    -- See Note [Sources of one-shot information]+    rhs_env = env1 { occ_one_shots = argOneShots dmd }++    (rhs_usage1, rhs') = occAnalRhs rhs_env mb_join_arity rhs++    -- Unfoldings+    -- See Note [Unfoldings and join points]+    unf = idUnfolding bndr+    (unf_usage, unf') = occAnalUnfolding rhs_env mb_join_arity unf+    rhs_usage2 = rhs_usage1 `andUDs` unf_usage++    -- Rules+    -- See Note [Rules are extra RHSs] and Note [Rule dependency info]+    rules_w_uds = occAnalRules rhs_env mb_join_arity bndr+    rule_uds    = map (\(_, l, r) -> l `andUDs` r) rules_w_uds+    rules'      = map fstOf3 rules_w_uds+    rhs_usage3 = foldr andUDs rhs_usage2 rule_uds+    rhs_usage4 = case lookupVarEnv imp_rule_edges bndr of+                   Nothing -> rhs_usage3+                   Just vs -> addManyOccs rhs_usage3 vs+       -- See Note [Preventing loops due to imported functions rules]++    certainly_inline -- See Note [Cascading inlines]+      = case occ of+          OneOcc { occ_in_lam = NotInsideLam, occ_one_br = InOneBranch }+            -> active && not_stable+          _ -> False++    dmd        = idDemandInfo bndr+    active     = isAlwaysActive (idInlineActivation bndr)+    not_stable = not (isStableUnfolding (idUnfolding bndr))++-----------------+occAnalRecBind :: OccEnv -> TopLevelFlag -> ImpRuleEdges -> [(Var,CoreExpr)]+               -> UsageDetails -> (UsageDetails, [CoreBind])+occAnalRecBind env lvl imp_rule_edges pairs body_usage+  = foldr (occAnalRec rhs_env lvl) (body_usage, []) sccs+        -- For a recursive group, we+        --      * occ-analyse all the RHSs+        --      * compute strongly-connected components+        --      * feed those components to occAnalRec+        -- See Note [Recursive bindings: the grand plan]+  where+    sccs :: [SCC Details]+    sccs = {-# SCC "occAnalBind.scc" #-}+           stronglyConnCompFromEdgedVerticesUniq nodes++    nodes :: [LetrecNode]+    nodes = {-# SCC "occAnalBind.assoc" #-}+            map (makeNode rhs_env imp_rule_edges bndr_set) pairs++    bndrs    = map fst pairs+    bndr_set = mkVarSet bndrs+    rhs_env  = env `addInScope` bndrs++{-+Note [Unfoldings and join points]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++We assume that anything in an unfolding occurs multiple times, since unfoldings+are often copied (that's the whole point!). But we still need to track tail+calls for the purpose of finding join points.+-}++-----------------------------+occAnalRec :: OccEnv -> TopLevelFlag+           -> SCC Details+           -> (UsageDetails, [CoreBind])+           -> (UsageDetails, [CoreBind])++        -- The NonRec case is just like a Let (NonRec ...) above+occAnalRec _ lvl (AcyclicSCC (ND { nd_bndr = bndr, nd_rhs = rhs+                                 , nd_uds = rhs_uds, nd_rhs_bndrs = rhs_bndrs }))+           (body_uds, binds)+  | not (bndr `usedIn` body_uds)+  = (body_uds, binds)           -- See Note [Dead code]++  | otherwise                   -- It's mentioned in the body+  = (body_uds' `andUDs` rhs_uds',+     NonRec tagged_bndr rhs : binds)+  where+    (body_uds', tagged_bndr) = tagNonRecBinder lvl body_uds bndr+    rhs_uds' = adjustRhsUsage (willBeJoinId_maybe tagged_bndr) NonRecursive+                              rhs_bndrs rhs_uds++        -- The Rec case is the interesting one+        -- See Note [Recursive bindings: the grand plan]+        -- See Note [Loop breaking]+occAnalRec env lvl (CyclicSCC details_s) (body_uds, binds)+  | not (any (`usedIn` body_uds) bndrs) -- NB: look at body_uds, not total_uds+  = (body_uds, binds)                   -- See Note [Dead code]++  | otherwise   -- At this point we always build a single Rec+  = -- pprTrace "occAnalRec" (vcat+    --   [ text "weak_fvs" <+> ppr weak_fvs+    --   , text "lb nodes" <+> ppr loop_breaker_nodes])+    (final_uds, Rec pairs : binds)++  where+    bndrs    = map nd_bndr details_s+    bndr_set = mkVarSet bndrs++    ------------------------------+        -- See Note [Choosing loop breakers] for loop_breaker_nodes+    final_uds :: UsageDetails+    loop_breaker_nodes :: [LetrecNode]+    (final_uds, loop_breaker_nodes)+      = mkLoopBreakerNodes env lvl bndr_set body_uds details_s++    ------------------------------+    weak_fvs :: VarSet+    weak_fvs = mapUnionVarSet nd_weak details_s++    ---------------------------+    -- Now reconstruct the cycle+    pairs :: [(Id,CoreExpr)]+    pairs | isEmptyVarSet weak_fvs = reOrderNodes   0 bndr_set weak_fvs loop_breaker_nodes []+          | otherwise              = loopBreakNodes 0 bndr_set weak_fvs loop_breaker_nodes []+          -- If weak_fvs is empty, the loop_breaker_nodes will include+          -- all the edges in the original scope edges [remember,+          -- weak_fvs is the difference between scope edges and+          -- lb-edges], so a fresh SCC computation would yield a+          -- single CyclicSCC result; and reOrderNodes deals with+          -- exactly that case+++------------------------------------------------------------------+--                 Loop breaking+------------------------------------------------------------------++type Binding = (Id,CoreExpr)++loopBreakNodes :: Int+               -> VarSet        -- All binders+               -> VarSet        -- Binders whose dependencies may be "missing"+                                -- See Note [Weak loop breakers]+               -> [LetrecNode]+               -> [Binding]             -- Append these to the end+               -> [Binding]+{-+loopBreakNodes is applied to the list of nodes for a cyclic strongly+connected component (there's guaranteed to be a cycle).  It returns+the same nodes, but+        a) in a better order,+        b) with some of the Ids having a IAmALoopBreaker pragma++The "loop-breaker" Ids are sufficient to break all cycles in the SCC.  This means+that the simplifier can guarantee not to loop provided it never records an inlining+for these no-inline guys.++Furthermore, the order of the binds is such that if we neglect dependencies+on the no-inline Ids then the binds are topologically sorted.  This means+that the simplifier will generally do a good job if it works from top bottom,+recording inlinings for any Ids which aren't marked as "no-inline" as it goes.+-}++-- Return the bindings sorted into a plausible order, and marked with loop breakers.+loopBreakNodes depth bndr_set weak_fvs nodes binds+  = -- pprTrace "loopBreakNodes" (ppr nodes) $+    go (stronglyConnCompFromEdgedVerticesUniqR nodes)+  where+    go []         = binds+    go (scc:sccs) = loop_break_scc scc (go sccs)++    loop_break_scc scc binds+      = case scc of+          AcyclicSCC node  -> mk_non_loop_breaker weak_fvs node : binds+          CyclicSCC nodes  -> reOrderNodes depth bndr_set weak_fvs nodes binds++----------------------------------+reOrderNodes :: Int -> VarSet -> VarSet -> [LetrecNode] -> [Binding] -> [Binding]+    -- Choose a loop breaker, mark it no-inline,+    -- and call loopBreakNodes on the rest+reOrderNodes _ _ _ []     _     = panic "reOrderNodes"+reOrderNodes _ _ _ [node] binds = mk_loop_breaker node : binds+reOrderNodes depth bndr_set weak_fvs (node : nodes) binds+  = -- pprTrace "reOrderNodes" (vcat [ text "unchosen" <+> ppr unchosen+    --                               , text "chosen" <+> ppr chosen_nodes ]) $+    loopBreakNodes new_depth bndr_set weak_fvs unchosen $+    (map mk_loop_breaker chosen_nodes ++ binds)+  where+    (chosen_nodes, unchosen) = chooseLoopBreaker approximate_lb+                                                 (nd_score (node_payload node))+                                                 [node] [] nodes++    approximate_lb = depth >= 2+    new_depth | approximate_lb = 0+              | otherwise      = depth+1+        -- After two iterations (d=0, d=1) give up+        -- and approximate, returning to d=0++mk_loop_breaker :: LetrecNode -> Binding+mk_loop_breaker (node_payload -> ND { nd_bndr = bndr, nd_rhs = rhs})+  = (bndr `setIdOccInfo` strongLoopBreaker { occ_tail = tail_info }, rhs)+  where+    tail_info = tailCallInfo (idOccInfo bndr)++mk_non_loop_breaker :: VarSet -> LetrecNode -> Binding+-- See Note [Weak loop breakers]+mk_non_loop_breaker weak_fvs (node_payload -> ND { nd_bndr = bndr+                                                 , nd_rhs = rhs})+  | bndr `elemVarSet` weak_fvs = (setIdOccInfo bndr occ', rhs)+  | otherwise                  = (bndr, rhs)+  where+    occ' = weakLoopBreaker { occ_tail = tail_info }+    tail_info = tailCallInfo (idOccInfo bndr)++----------------------------------+chooseLoopBreaker :: Bool             -- True <=> Too many iterations,+                                      --          so approximate+                  -> NodeScore            -- Best score so far+                  -> [LetrecNode]       -- Nodes with this score+                  -> [LetrecNode]       -- Nodes with higher scores+                  -> [LetrecNode]       -- Unprocessed nodes+                  -> ([LetrecNode], [LetrecNode])+    -- This loop looks for the bind with the lowest score+    -- to pick as the loop  breaker.  The rest accumulate in+chooseLoopBreaker _ _ loop_nodes acc []+  = (loop_nodes, acc)        -- Done++    -- If approximate_loop_breaker is True, we pick *all*+    -- nodes with lowest score, else just one+    -- See Note [Complexity of loop breaking]+chooseLoopBreaker approx_lb loop_sc loop_nodes acc (node : nodes)+  | approx_lb+  , rank sc == rank loop_sc+  = chooseLoopBreaker approx_lb loop_sc (node : loop_nodes) acc nodes++  | sc `betterLB` loop_sc  -- Better score so pick this new one+  = chooseLoopBreaker approx_lb sc [node] (loop_nodes ++ acc) nodes++  | otherwise              -- Worse score so don't pick it+  = chooseLoopBreaker approx_lb loop_sc loop_nodes (node : acc) nodes+  where+    sc = nd_score (node_payload node)++{-+Note [Complexity of loop breaking]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The loop-breaking algorithm knocks out one binder at a time, and+performs a new SCC analysis on the remaining binders.  That can+behave very badly in tightly-coupled groups of bindings; in the+worst case it can be (N**2)*log N, because it does a full SCC+on N, then N-1, then N-2 and so on.++To avoid this, we switch plans after 2 (or whatever) attempts:+  Plan A: pick one binder with the lowest score, make it+          a loop breaker, and try again+  Plan B: pick *all* binders with the lowest score, make them+          all loop breakers, and try again+Since there are only a small finite number of scores, this will+terminate in a constant number of iterations, rather than O(N)+iterations.++You might thing that it's very unlikely, but RULES make it much+more likely.  Here's a real example from #1969:+  Rec { $dm = \d.\x. op d+        {-# RULES forall d. $dm Int d  = $s$dm1+                  forall d. $dm Bool d = $s$dm2 #-}++        dInt = MkD .... opInt ...+        dInt = MkD .... opBool ...+        opInt  = $dm dInt+        opBool = $dm dBool++        $s$dm1 = \x. op dInt+        $s$dm2 = \x. op dBool }+The RULES stuff means that we can't choose $dm as a loop breaker+(Note [Choosing loop breakers]), so we must choose at least (say)+opInt *and* opBool, and so on.  The number of loop breakders is+linear in the number of instance declarations.++Note [Loop breakers and INLINE/INLINABLE pragmas]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Avoid choosing a function with an INLINE pramga as the loop breaker!+If such a function is mutually-recursive with a non-INLINE thing,+then the latter should be the loop-breaker.++It's vital to distinguish between INLINE and INLINABLE (the+Bool returned by hasStableCoreUnfolding_maybe).  If we start with+   Rec { {-# INLINABLE f #-}+         f x = ...f... }+and then worker/wrapper it through strictness analysis, we'll get+   Rec { {-# INLINABLE $wf #-}+         $wf p q = let x = (p,q) in ...f...++         {-# INLINE f #-}+         f x = case x of (p,q) -> $wf p q }++Now it is vital that we choose $wf as the loop breaker, so we can+inline 'f' in '$wf'.++Note [DFuns should not be loop breakers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's particularly bad to make a DFun into a loop breaker.  See+Note [How instance declarations are translated] in GHC.Tc.TyCl.Instance++We give DFuns a higher score than ordinary CONLIKE things because+if there's a choice we want the DFun to be the non-loop breaker. Eg++rec { sc = /\ a \$dC. $fBWrap (T a) ($fCT @ a $dC)++      $fCT :: forall a_afE. (Roman.C a_afE) => Roman.C (Roman.T a_afE)+      {-# DFUN #-}+      $fCT = /\a \$dC. MkD (T a) ((sc @ a $dC) |> blah) ($ctoF @ a $dC)+    }++Here 'sc' (the superclass) looks CONLIKE, but we'll never get to it+if we can't unravel the DFun first.++Note [Constructor applications]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's really really important to inline dictionaries.  Real+example (the Enum Ordering instance from GHC.Base):++     rec     f = \ x -> case d of (p,q,r) -> p x+             g = \ x -> case d of (p,q,r) -> q x+             d = (v, f, g)++Here, f and g occur just once; but we can't inline them into d.+On the other hand we *could* simplify those case expressions if+we didn't stupidly choose d as the loop breaker.+But we won't because constructor args are marked "Many".+Inlining dictionaries is really essential to unravelling+the loops in static numeric dictionaries, see GHC.Float.++Note [Closure conversion]+~~~~~~~~~~~~~~~~~~~~~~~~~+We treat (\x. C p q) as a high-score candidate in the letrec scoring algorithm.+The immediate motivation came from the result of a closure-conversion transformation+which generated code like this:++    data Clo a b = forall c. Clo (c -> a -> b) c++    ($:) :: Clo a b -> a -> b+    Clo f env $: x = f env x++    rec { plus = Clo plus1 ()++        ; plus1 _ n = Clo plus2 n++        ; plus2 Zero     n = n+        ; plus2 (Succ m) n = Succ (plus $: m $: n) }++If we inline 'plus' and 'plus1', everything unravels nicely.  But if+we choose 'plus1' as the loop breaker (which is entirely possible+otherwise), the loop does not unravel nicely.+++@occAnalUnfolding@ deals with the question of bindings where the Id is marked+by an INLINE pragma.  For these we record that anything which occurs+in its RHS occurs many times.  This pessimistically assumes that this+inlined binder also occurs many times in its scope, but if it doesn't+we'll catch it next time round.  At worst this costs an extra simplifier pass.+ToDo: try using the occurrence info for the inline'd binder.++[March 97] We do the same for atomic RHSs.  Reason: see notes with loopBreakSCC.+[June 98, SLPJ]  I've undone this change; I don't understand it.  See notes with loopBreakSCC.+++************************************************************************+*                                                                      *+                   Making nodes+*                                                                      *+************************************************************************+-}++type ImpRuleEdges = IdEnv IdSet     -- Mapping from FVs of imported RULE LHSs to RHS FVs++noImpRuleEdges :: ImpRuleEdges+noImpRuleEdges = emptyVarEnv++type LetrecNode = Node Unique Details  -- Node comes from Digraph+                                       -- The Unique key is gotten from the Id+data Details+  = ND { nd_bndr :: Id          -- Binder++       , nd_rhs  :: CoreExpr    -- RHS, already occ-analysed++       , nd_rhs_bndrs :: [CoreBndr] -- Outer lambdas of RHS+                                    -- INVARIANT: (nd_rhs_bndrs nd, _) ==+                                    --              collectBinders (nd_rhs nd)++       , nd_uds  :: UsageDetails  -- Usage from RHS, and RULES, and stable unfoldings+                                  -- ignoring phase (ie assuming all are active)+                                  -- See Note [Forming Rec groups]++       , nd_inl  :: IdSet       -- Free variables of+                                --   the stable unfolding (if present and active)+                                --   or the RHS (if not)+                                -- but excluding any RULES+                                -- This is the IdSet that may be used if the Id is inlined++       , nd_weak :: IdSet       -- Binders of this Rec that are mentioned in nd_uds+                                -- but are *not* in nd_inl.  These are the ones whose+                                -- dependencies might not be respected by loop_breaker_nodes+                                -- See Note [Weak loop breakers]++       , nd_active_rule_fvs :: IdSet   -- Free variables of the RHS of active RULES++       , nd_score :: NodeScore+  }++instance Outputable Details where+   ppr nd = text "ND" <> braces+             (sep [ text "bndr =" <+> ppr (nd_bndr nd)+                  , text "uds =" <+> ppr (nd_uds nd)+                  , text "inl =" <+> ppr (nd_inl nd)+                  , text "weak =" <+> ppr (nd_weak nd)+                  , text "rule =" <+> ppr (nd_active_rule_fvs nd)+                  , text "score =" <+> ppr (nd_score nd)+             ])++-- The NodeScore is compared lexicographically;+--      e.g. lower rank wins regardless of size+type NodeScore = ( Int     -- Rank: lower => more likely to be picked as loop breaker+                 , Int     -- Size of rhs: higher => more likely to be picked as LB+                           -- Maxes out at maxExprSize; we just use it to prioritise+                           -- small functions+                 , Bool )  -- Was it a loop breaker before?+                           -- True => more likely to be picked+                           -- Note [Loop breakers, node scoring, and stability]++rank :: NodeScore -> Int+rank (r, _, _) = r++makeNode :: OccEnv -> ImpRuleEdges -> VarSet+         -> (Var, CoreExpr) -> LetrecNode+-- See Note [Recursive bindings: the grand plan]+makeNode env imp_rule_edges bndr_set (bndr, rhs)+  = DigraphNode details (varUnique bndr) (nonDetKeysUniqSet node_fvs)+    -- It's OK to use nonDetKeysUniqSet here as stronglyConnCompFromEdgedVerticesR+    -- is still deterministic with edges in nondeterministic order as+    -- explained in Note [Deterministic SCC] in GHC.Data.Graph.Directed.+  where+    details = ND { nd_bndr            = bndr'+                 , nd_rhs             = rhs'+                 , nd_rhs_bndrs       = bndrs'+                 , nd_uds             = rhs_usage3+                 , nd_inl             = inl_fvs+                 , nd_weak            = node_fvs `minusVarSet` inl_fvs+                 , nd_active_rule_fvs = active_rule_fvs+                 , nd_score           = pprPanic "makeNodeDetails" (ppr bndr) }++    bndr' = bndr `setIdUnfolding`      unf'+                 `setIdSpecialisation` mkRuleInfo rules'++    -- Get join point info from the *current* decision+    -- We don't know what the new decision will be!+    -- Using the old decision at least allows us to+    -- preserve existing join point, even RULEs are added+    -- See Note [Join points and unfoldings/rules]+    mb_join_arity = isJoinId_maybe bndr++    -- Constructing the edges for the main Rec computation+    -- See Note [Forming Rec groups]+    (bndrs, body) = collectBinders rhs+    rhs_env       = rhsCtxt env+    (rhs_usage1, bndrs', body') = occAnalLamOrRhs rhs_env bndrs body+    rhs'       = mkLams bndrs' body'+    rhs_usage3 = foldr andUDs rhs_usage1 rule_uds+                 `andUDs` unf_uds+                   -- Note [Rules are extra RHSs]+                   -- Note [Rule dependency info]+    node_fvs   = udFreeVars bndr_set rhs_usage3++    -- Finding the free variables of the rules+    is_active = occ_rule_act env :: Activation -> Bool++    rules_w_uds :: [(CoreRule, UsageDetails, UsageDetails)]+    rules_w_uds = occAnalRules rhs_env mb_join_arity bndr++    rules' = map fstOf3 rules_w_uds++    rules_w_rhs_fvs :: [(Activation, VarSet)]    -- Find the RHS fvs+    rules_w_rhs_fvs = maybe id (\ids -> ((AlwaysActive, ids):))+                               (lookupVarEnv imp_rule_edges bndr)+      -- See Note [Preventing loops due to imported functions rules]+                      [ (ru_act rule, udFreeVars bndr_set rhs_uds)+                      | (rule, _, rhs_uds) <- rules_w_uds ]+    rule_uds = map (\(_, l, r) -> l `andUDs` r) rules_w_uds+    active_rule_fvs = unionVarSets [fvs | (a,fvs) <- rules_w_rhs_fvs+                                        , is_active a]++    -- Finding the usage details of the INLINE pragma (if any)+    unf = realIdUnfolding bndr -- realIdUnfolding: Ignore loop-breaker-ness+                               -- here because that is what we are setting!+    (unf_uds, unf') = occAnalUnfolding rhs_env mb_join_arity unf++    -- Find the "nd_inl" free vars; for the loop-breaker phase+    -- These are the vars that would become free if the function+    -- was inlinined; usually that means the RHS, unless the+    -- unfolding is a stable one.+    -- Note: We could do this only for functions with an *active* unfolding+    --       (returning emptyVarSet for an inactive one), but is_active+    --       isn't the right thing (it tells about RULE activation),+    --       so we'd need more plumbing+    inl_fvs | isStableUnfolding unf = udFreeVars bndr_set unf_uds+            | otherwise             = udFreeVars bndr_set rhs_usage1++mkLoopBreakerNodes :: OccEnv -> TopLevelFlag+                   -> VarSet+                   -> UsageDetails   -- for BODY of let+                   -> [Details]+                   -> (UsageDetails, -- adjusted+                       [LetrecNode])+-- Does four things+--   a) tag each binder with its occurrence info+--   b) add a NodeScore to each node+--   c) make a Node with the right dependency edges for+--      the loop-breaker SCC analysis+--   d) adjust each RHS's usage details according to+--      the binder's (new) shotness and join-point-hood+mkLoopBreakerNodes env lvl bndr_set body_uds details_s+  = (final_uds, zipWithEqual "mkLoopBreakerNodes" mk_lb_node details_s bndrs')+  where+    (final_uds, bndrs')+       = tagRecBinders lvl body_uds+            [ (bndr, uds, rhs_bndrs)+            | ND { nd_bndr = bndr, nd_uds = uds, nd_rhs_bndrs = rhs_bndrs }+                 <- details_s ]++    mk_lb_node nd@(ND { nd_bndr = old_bndr, nd_inl = inl_fvs }) new_bndr+      = DigraphNode nd' (varUnique old_bndr) (nonDetKeysUniqSet lb_deps)+              -- It's OK to use nonDetKeysUniqSet here as+              -- stronglyConnCompFromEdgedVerticesR is still deterministic with edges+              -- in nondeterministic order as explained in+              -- Note [Deterministic SCC] in GHC.Data.Graph.Directed.+      where+        nd'     = nd { nd_bndr = new_bndr, nd_score = score }+        score   = nodeScore env new_bndr lb_deps nd+        lb_deps = extendFvs_ rule_fv_env inl_fvs+++    rule_fv_env :: IdEnv IdSet+        -- Maps a variable f to the variables from this group+        --      mentioned in RHS of active rules for f+        -- Domain is *subset* of bound vars (others have no rule fvs)+    rule_fv_env = transClosureFV (mkVarEnv init_rule_fvs)+    init_rule_fvs   -- See Note [Finding rule RHS free vars]+      = [ (b, trimmed_rule_fvs)+        | ND { nd_bndr = b, nd_active_rule_fvs = rule_fvs } <- details_s+        , let trimmed_rule_fvs = rule_fvs `intersectVarSet` bndr_set+        , not (isEmptyVarSet trimmed_rule_fvs) ]+++------------------------------------------+nodeScore :: OccEnv+          -> Id        -- Binder with new occ-info+          -> VarSet    -- Loop-breaker dependencies+          -> Details+          -> NodeScore+nodeScore env new_bndr lb_deps+          (ND { nd_bndr = old_bndr, nd_rhs = bind_rhs })++  | not (isId old_bndr)     -- A type or coercion variable is never a loop breaker+  = (100, 0, False)++  | old_bndr `elemVarSet` lb_deps  -- Self-recursive things are great loop breakers+  = (0, 0, True)                   -- See Note [Self-recursion and loop breakers]++  | not (occ_unf_act env old_bndr) -- A binder whose inlining is inactive (e.g. has+  = (0, 0, True)                   -- a NOINLINE pragma) makes a great loop breaker++  | exprIsTrivial rhs+  = mk_score 10  -- Practically certain to be inlined+    -- Used to have also: && not (isExportedId bndr)+    -- But I found this sometimes cost an extra iteration when we have+    --      rec { d = (a,b); a = ...df...; b = ...df...; df = d }+    -- where df is the exported dictionary. Then df makes a really+    -- bad choice for loop breaker++  | DFunUnfolding { df_args = args } <- old_unf+    -- Never choose a DFun as a loop breaker+    -- Note [DFuns should not be loop breakers]+  = (9, length args, is_lb)++    -- Data structures are more important than INLINE pragmas+    -- so that dictionary/method recursion unravels++  | CoreUnfolding { uf_guidance = UnfWhen {} } <- old_unf+  = mk_score 6++  | is_con_app rhs   -- Data types help with cases:+  = mk_score 5       -- Note [Constructor applications]++  | isStableUnfolding old_unf+  , can_unfold+  = mk_score 3++  | isOneOcc (idOccInfo new_bndr)+  = mk_score 2  -- Likely to be inlined++  | can_unfold  -- The Id has some kind of unfolding+  = mk_score 1++  | otherwise+  = (0, 0, is_lb)++  where+    mk_score :: Int -> NodeScore+    mk_score rank = (rank, rhs_size, is_lb)++    -- is_lb: see Note [Loop breakers, node scoring, and stability]+    is_lb = isStrongLoopBreaker (idOccInfo old_bndr)++    old_unf = realIdUnfolding old_bndr+    can_unfold = canUnfold old_unf+    rhs        = case old_unf of+                   CoreUnfolding { uf_src = src, uf_tmpl = unf_rhs }+                     | isStableSource src+                     -> unf_rhs+                   _ -> bind_rhs+       -- 'bind_rhs' is irrelevant for inlining things with a stable unfolding+    rhs_size = case old_unf of+                 CoreUnfolding { uf_guidance = guidance }+                    | UnfIfGoodArgs { ug_size = size } <- guidance+                    -> size+                 _  -> cheapExprSize rhs+++        -- Checking for a constructor application+        -- Cheap and cheerful; the simplifier moves casts out of the way+        -- The lambda case is important to spot x = /\a. C (f a)+        -- which comes up when C is a dictionary constructor and+        -- f is a default method.+        -- Example: the instance for Show (ST s a) in GHC.ST+        --+        -- However we *also* treat (\x. C p q) as a con-app-like thing,+        --      Note [Closure conversion]+    is_con_app (Var v)    = isConLikeId v+    is_con_app (App f _)  = is_con_app f+    is_con_app (Lam _ e)  = is_con_app e+    is_con_app (Tick _ e) = is_con_app e+    is_con_app _          = False++maxExprSize :: Int+maxExprSize = 20  -- Rather arbitrary++cheapExprSize :: CoreExpr -> Int+-- Maxes out at maxExprSize+cheapExprSize e+  = go 0 e+  where+    go n e | n >= maxExprSize = n+           | otherwise        = go1 n e++    go1 n (Var {})        = n+1+    go1 n (Lit {})        = n+1+    go1 n (Type {})       = n+    go1 n (Coercion {})   = n+    go1 n (Tick _ e)      = go1 n e+    go1 n (Cast e _)      = go1 n e+    go1 n (App f a)       = go (go1 n f) a+    go1 n (Lam b e)+      | isTyVar b         = go1 n e+      | otherwise         = go (n+1) e+    go1 n (Let b e)       = gos (go1 n e) (rhssOfBind b)+    go1 n (Case e _ _ as) = gos (go1 n e) (rhssOfAlts as)++    gos n [] = n+    gos n (e:es) | n >= maxExprSize = n+                 | otherwise        = gos (go1 n e) es++betterLB :: NodeScore -> NodeScore -> Bool+-- If  n1 `betterLB` n2  then choose n1 as the loop breaker+betterLB (rank1, size1, lb1) (rank2, size2, _)+  | rank1 < rank2 = True+  | rank1 > rank2 = False+  | size1 < size2 = False   -- Make the bigger n2 into the loop breaker+  | size1 > size2 = True+  | lb1           = True    -- Tie-break: if n1 was a loop breaker before, choose it+  | otherwise     = False   -- See Note [Loop breakers, node scoring, and stability]++{- Note [Self-recursion and loop breakers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If we have+   rec { f = ...f...g...+       ; g = .....f...   }+then 'f' has to be a loop breaker anyway, so we may as well choose it+right away, so that g can inline freely.++This is really just a cheap hack. Consider+   rec { f = ...g...+       ; g = ..f..h...+      ;  h = ...f....}+Here f or g are better loop breakers than h; but we might accidentally+choose h.  Finding the minimal set of loop breakers is hard.++Note [Loop breakers, node scoring, and stability]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+To choose a loop breaker, we give a NodeScore to each node in the SCC,+and pick the one with the best score (according to 'betterLB').++We need to be jolly careful (#12425, #12234) about the stability+of this choice. Suppose we have++    let rec { f = ...g...g...+            ; g = ...f...f... }+    in+    case x of+      True  -> ...f..+      False -> ..f...++In each iteration of the simplifier the occurrence analyser OccAnal+chooses a loop breaker. Suppose in iteration 1 it choose g as the loop+breaker. That means it is free to inline f.++Suppose that GHC decides to inline f in the branches of the case, but+(for some reason; eg it is not saturated) in the rhs of g. So we get++    let rec { f = ...g...g...+            ; g = ...f...f... }+    in+    case x of+      True  -> ...g...g.....+      False -> ..g..g....++Now suppose that, for some reason, in the next iteration the occurrence+analyser chooses f as the loop breaker, so it can freely inline g. And+again for some reason the simplifier inlines g at its calls in the case+branches, but not in the RHS of f. Then we get++    let rec { f = ...g...g...+            ; g = ...f...f... }+    in+    case x of+      True  -> ...(...f...f...)...(...f..f..).....+      False -> ..(...f...f...)...(..f..f...)....++You can see where this is going! Each iteration of the simplifier+doubles the number of calls to f or g. No wonder GHC is slow!++(In the particular example in comment:3 of #12425, f and g are the two+mutually recursive fmap instances for CondT and Result. They are both+marked INLINE which, oddly, is why they don't inline in each other's+RHS, because the call there is not saturated.)++The root cause is that we flip-flop on our choice of loop breaker. I+always thought it didn't matter, and indeed for any single iteration+to terminate, it doesn't matter. But when we iterate, it matters a+lot!!++So The Plan is this:+   If there is a tie, choose the node that+   was a loop breaker last time round++Hence the is_lb field of NodeScore++************************************************************************+*                                                                      *+                   Right hand sides+*                                                                      *+************************************************************************+-}++occAnalRhs :: OccEnv -> Maybe JoinArity+           -> CoreExpr   -- RHS+           -> (UsageDetails, CoreExpr)+occAnalRhs env mb_join_arity rhs+  = (rhs_usage, rhs')+  where+    (bndrs, body) = collectBinders rhs+    (body_usage, bndrs', body') = occAnalLamOrRhs env bndrs body+    rhs' = mkLams (markJoinOneShots mb_join_arity bndrs') body'+           -- For a /non-recursive/ join point we can mark all+           -- its join-lambda as one-shot; and it's a good idea to do so++    -- Final adjustment+    rhs_usage = adjustRhsUsage mb_join_arity NonRecursive bndrs' body_usage++occAnalUnfolding :: OccEnv+                 -> Maybe JoinArity   -- See Note [Join points and unfoldings/rules]+                 -> Unfolding+                 -> (UsageDetails, Unfolding)+-- Occurrence-analyse a stable unfolding;+-- discard a non-stable one altogether.+occAnalUnfolding env mb_join_arity unf+  = case unf of+      unf@(CoreUnfolding { uf_tmpl = rhs, uf_src = src })+        | isStableSource src -> (usage,        unf')+        | otherwise          -> (emptyDetails, unf)+        where -- For non-Stable unfoldings we leave them undisturbed, but+              -- don't count their usage because the simplifier will discard them.+              -- We leave them undisturbed because nodeScore uses their size info+              -- to guide its decisions.  It's ok to leave un-substituted+              -- expressions in the tree because all the variables that were in+              -- scope remain in scope; there is no cloning etc.+          (usage, rhs') = occAnalRhs env mb_join_arity rhs++          unf' | noBinderSwaps env = unf -- Note [Unfoldings and rules]+               | otherwise         = unf { uf_tmpl = rhs' }++      unf@(DFunUnfolding { df_bndrs = bndrs, df_args = args })+        -> ( final_usage, unf { df_args = args' } )+        where+          env'            = env `addInScope` bndrs+          (usage, args')  = occAnalList env' args+          final_usage     = markAllManyNonTail (delDetailsList usage bndrs)++      unf -> (emptyDetails, unf)++occAnalRules :: OccEnv+             -> Maybe JoinArity  -- See Note [Join points and unfoldings/rules]+             -> Id               -- Get rules from here+             -> [(CoreRule,      -- Each (non-built-in) rule+                  UsageDetails,  -- Usage details for LHS+                  UsageDetails)] -- Usage details for RHS+occAnalRules env mb_join_arity bndr+  = map occ_anal_rule (idCoreRules bndr)+  where+    occ_anal_rule rule@(Rule { ru_bndrs = bndrs, ru_args = args, ru_rhs = rhs })+      = (rule', lhs_uds', rhs_uds')+      where+        env' = env `addInScope` bndrs+        rule' | noBinderSwaps env = rule  -- Note [Unfoldings and rules]+              | otherwise         = rule { ru_args = args', ru_rhs = rhs' }++        (lhs_uds, args') = occAnalList env' args+        lhs_uds'         = markAllManyNonTail $+                           lhs_uds `delDetailsList` bndrs++        (rhs_uds, rhs') = occAnal env' rhs+                            -- Note [Rules are extra RHSs]+                            -- Note [Rule dependency info]+        rhs_uds' = markAllNonTailIf (not exact_join) $+                   markAllMany                             $+                   rhs_uds `delDetailsList` bndrs++        exact_join = exactJoin mb_join_arity args+                     -- See Note [Join points and unfoldings/rules]++    occ_anal_rule other_rule = (other_rule, emptyDetails, emptyDetails)++{- Note [Join point RHSs]+~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+   x = e+   join j = Just x++We want to inline x into j right away, so we don't want to give+the join point a RhsCtxt (#14137).  It's not a huge deal, because+the FloatIn pass knows to float into join point RHSs; and the simplifier+does not float things out of join point RHSs.  But it's a simple, cheap+thing to do.  See #14137.++Note [Unfoldings and rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Generally unfoldings and rules are already occurrence-analysed, so we+don't want to reconstruct their trees; we just want to analyse them to+find how they use their free variables.++EXCEPT if there is a binder-swap going on, in which case we do want to+produce a new tree.++So we have a fast-path that keeps the old tree if the occ_bs_env is+empty.   This just saves a bit of allocation and reconstruction; not+a big deal.++Note [Cascading inlines]+~~~~~~~~~~~~~~~~~~~~~~~~+By default we use an rhsCtxt for the RHS of a binding.  This tells the+occ anal n that it's looking at an RHS, which has an effect in+occAnalApp.  In particular, for constructor applications, it makes+the arguments appear to have NoOccInfo, so that we don't inline into+them. Thus    x = f y+              k = Just x+we do not want to inline x.++But there's a problem.  Consider+     x1 = a0 : []+     x2 = a1 : x1+     x3 = a2 : x2+     g  = f x3+First time round, it looks as if x1 and x2 occur as an arg of a+let-bound constructor ==> give them a many-occurrence.+But then x3 is inlined (unconditionally as it happens) and+next time round, x2 will be, and the next time round x1 will be+Result: multiple simplifier iterations.  Sigh.++So, when analysing the RHS of x3 we notice that x3 will itself+definitely inline the next time round, and so we analyse x3's rhs in+an ordinary context, not rhsCtxt.  Hence the "certainly_inline" stuff.++Annoyingly, we have to approximate GHC.Core.Opt.Simplify.Utils.preInlineUnconditionally.+If (a) the RHS is expandable (see isExpandableApp in occAnalApp), and+   (b) certainly_inline says "yes" when preInlineUnconditionally says "no"+then the simplifier iterates indefinitely:+        x = f y+        k = Just x   -- We decide that k is 'certainly_inline'+        v = ...k...  -- but preInlineUnconditionally doesn't inline it+inline ==>+        k = Just (f y)+        v = ...k...+float ==>+        x1 = f y+        k = Just x1+        v = ...k...++This is worse than the slow cascade, so we only want to say "certainly_inline"+if it really is certain.  Look at the note with preInlineUnconditionally+for the various clauses.+++************************************************************************+*                                                                      *+                Expressions+*                                                                      *+************************************************************************+-}++occAnalList :: OccEnv -> [CoreExpr] -> (UsageDetails, [CoreExpr])+occAnalList _   []     = (emptyDetails, [])+occAnalList env (e:es) = case occAnal env e      of { (uds1, e')  ->+                         case occAnalList env es of { (uds2, es') ->+                         (uds1 `andUDs` uds2, e' : es') } }++occAnal :: OccEnv+        -> CoreExpr+        -> (UsageDetails,       -- Gives info only about the "interesting" Ids+            CoreExpr)++occAnal _   expr@(Type _) = (emptyDetails,         expr)+occAnal _   expr@(Lit _)  = (emptyDetails,         expr)+occAnal env expr@(Var _)  = occAnalApp env (expr, [], [])+    -- At one stage, I gathered the idRuleVars for the variable here too,+    -- which in a way is the right thing to do.+    -- But that went wrong right after specialisation, when+    -- the *occurrences* of the overloaded function didn't have any+    -- rules in them, so the *specialised* versions looked as if they+    -- weren't used at all.++occAnal _ (Coercion co)+  = (addManyOccs emptyDetails (coVarsOfCo co), Coercion co)+        -- See Note [Gather occurrences of coercion variables]++{-+Note [Gather occurrences of coercion variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We need to gather info about what coercion variables appear, so that+we can sort them into the right place when doing dependency analysis.+-}++occAnal env (Tick tickish body)+  | SourceNote{} <- tickish+  = (usage, Tick tickish body')+                  -- SourceNotes are best-effort; so we just proceed as usual.+                  -- If we drop a tick due to the issues described below it's+                  -- not the end of the world.++  | tickish `tickishScopesLike` SoftScope+  = (markAllNonTail usage, Tick tickish body')++  | Breakpoint _ ids <- tickish+  = (usage_lam `andUDs` foldr addManyOcc emptyDetails ids, Tick tickish body')+    -- never substitute for any of the Ids in a Breakpoint++  | otherwise+  = (usage_lam, Tick tickish body')+  where+    !(usage,body') = occAnal env body+    -- for a non-soft tick scope, we can inline lambdas only+    usage_lam = markAllNonTail (markAllInsideLam usage)+                  -- TODO There may be ways to make ticks and join points play+                  -- nicer together, but right now there are problems:+                  --   let j x = ... in tick<t> (j 1)+                  -- Making j a join point may cause the simplifier to drop t+                  -- (if the tick is put into the continuation). So we don't+                  -- count j 1 as a tail call.+                  -- See #14242.++occAnal env (Cast expr co)+  = case occAnal env expr of { (usage, expr') ->+    let usage1 = markAllManyNonTailIf (isRhsEnv env) usage+          -- usage1: if we see let x = y `cast` co+          -- then mark y as 'Many' so that we don't+          -- immediately inline y again.+        usage2 = addManyOccs usage1 (coVarsOfCo co)+          -- usage2: see Note [Gather occurrences of coercion variables]+    in (markAllNonTail usage2, Cast expr' co)+    }++occAnal env app@(App _ _)+  = occAnalApp env (collectArgsTicks tickishFloatable app)++-- Ignore type variables altogether+--   (a) occurrences inside type lambdas only not marked as InsideLam+--   (b) type variables not in environment++occAnal env (Lam x body)+  | isTyVar x+  = case occAnal env body of { (body_usage, body') ->+    (markAllNonTail body_usage, Lam x body')+    }++-- For value lambdas we do a special hack.  Consider+--      (\x. \y. ...x...)+-- If we did nothing, x is used inside the \y, so would be marked+-- as dangerous to dup.  But in the common case where the abstraction+-- is applied to two arguments this is over-pessimistic.+-- So instead, we just mark each binder with its occurrence+-- info in the *body* of the multiple lambda.+-- Then, the simplifier is careful when partially applying lambdas.++occAnal env expr@(Lam _ _)+  = case occAnalLamOrRhs env bndrs body of { (usage, tagged_bndrs, body') ->+    let+        expr'       = mkLams tagged_bndrs body'+        usage1      = markAllNonTail usage+        one_shot_gp = all isOneShotBndr tagged_bndrs+        final_usage = markAllInsideLamIf (not one_shot_gp) usage1+    in+    (final_usage, expr') }+  where+    (bndrs, body) = collectBinders expr++occAnal env (Case scrut bndr ty alts)+  = case occAnal (scrutCtxt env alts) scrut of { (scrut_usage, scrut') ->+    let alt_env = addBndrSwap scrut' bndr $+                  env { occ_encl = OccVanilla } `addInScope` [bndr]+    in+    case mapAndUnzip (occAnalAlt alt_env) alts of { (alts_usage_s, alts')   ->+    let+        alts_usage  = foldr orUDs emptyDetails alts_usage_s+        (alts_usage1, tagged_bndr) = tagLamBinder alts_usage bndr+        total_usage = markAllNonTail scrut_usage `andUDs` alts_usage1+                        -- Alts can have tail calls, but the scrutinee can't+    in+    total_usage `seq` (total_usage, Case scrut' tagged_bndr ty alts') }}++occAnal env (Let bind body)+  = case occAnal (env `addInScope` bindersOf bind)+                 body                    of { (body_usage, body') ->+    case occAnalBind env NotTopLevel+                     noImpRuleEdges bind+                     body_usage          of { (final_usage, new_binds) ->+       (final_usage, mkLets new_binds body') }}++occAnalArgs :: OccEnv -> [CoreExpr] -> [OneShots] -> (UsageDetails, [CoreExpr])+occAnalArgs _ [] _+  = (emptyDetails, [])++occAnalArgs env (arg:args) one_shots+  | isTypeArg arg+  = case occAnalArgs env args one_shots of { (uds, args') ->+    (uds, arg:args') }++  | otherwise+  = case argCtxt env one_shots           of { (arg_env, one_shots') ->+    case occAnal arg_env arg             of { (uds1, arg') ->+    case occAnalArgs env args one_shots' of { (uds2, args') ->+    (uds1 `andUDs` uds2, arg':args') }}}++{-+Applications are dealt with specially because we want+the "build hack" to work.++Note [Arguments of let-bound constructors]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+    f x = let y = expensive x in+          let z = (True,y) in+          (case z of {(p,q)->q}, case z of {(p,q)->q})+We feel free to duplicate the WHNF (True,y), but that means+that y may be duplicated thereby.++If we aren't careful we duplicate the (expensive x) call!+Constructors are rather like lambdas in this way.+-}++occAnalApp :: OccEnv+           -> (Expr CoreBndr, [Arg CoreBndr], [Tickish Id])+           -> (UsageDetails, Expr CoreBndr)+-- Naked variables (not applied) end up here too+occAnalApp env (Var fun, args, ticks)+  | null ticks = (all_uds, mkApps fun' args')+  | otherwise  = (all_uds, mkTicks ticks $ mkApps fun' args')+  where+    (fun', fun_id') = lookupVarEnv (occ_bs_env env) fun+                      `orElse` (Var fun, fun)+                     -- See Note [The binder-swap substitution]++    fun_uds = mkOneOcc fun_id' int_cxt n_args+    all_uds = fun_uds `andUDs` final_args_uds++    !(args_uds, args') = occAnalArgs env args one_shots+    !final_args_uds = markAllNonTail                        $+                      markAllInsideLamIf (isRhsEnv env && is_exp) $+                      args_uds+       -- We mark the free vars of the argument of a constructor or PAP+       -- as "inside-lambda", if it is the RHS of a let(rec).+       -- This means that nothing gets inlined into a constructor or PAP+       -- argument position, which is what we want.  Typically those+       -- constructor arguments are just variables, or trivial expressions.+       -- We use inside-lam because it's like eta-expanding the PAP.+       --+       -- This is the *whole point* of the isRhsEnv predicate+       -- See Note [Arguments of let-bound constructors]++    n_val_args = valArgCount args+    n_args     = length args+    int_cxt    = case occ_encl env of+                   OccScrut -> IsInteresting+                   _other   | n_val_args > 0 -> IsInteresting+                            | otherwise      -> NotInteresting++    is_exp     = isExpandableApp fun n_val_args+        -- See Note [CONLIKE pragma] in GHC.Types.Basic+        -- The definition of is_exp should match that in GHC.Core.Opt.Simplify.prepareRhs++    one_shots  = argsOneShots (idStrictness fun) guaranteed_val_args+    guaranteed_val_args = n_val_args + length (takeWhile isOneShotInfo+                                                         (occ_one_shots env))+        -- See Note [Sources of one-shot information], bullet point A']++occAnalApp env (fun, args, ticks)+  = (markAllNonTail (fun_uds `andUDs` args_uds),+     mkTicks ticks $ mkApps fun' args')+  where+    !(fun_uds, fun') = occAnal (addAppCtxt env args) fun+        -- The addAppCtxt is a bit cunning.  One iteration of the simplifier+        -- often leaves behind beta redexs like+        --      (\x y -> e) a1 a2+        -- Here we would like to mark x,y as one-shot, and treat the whole+        -- thing much like a let.  We do this by pushing some True items+        -- onto the context stack.+    !(args_uds, args') = occAnalArgs env args []+++{-+Note [Sources of one-shot information]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The occurrence analyser obtains one-shot-lambda information from two sources:++A:  Saturated applications:  eg   f e1 .. en++    In general, given a call (f e1 .. en) we can propagate one-shot info from+    f's strictness signature into e1 .. en, but /only/ if n is enough to+    saturate the strictness signature. A strictness signature like++          f :: C1(C1(L))LS++    means that *if f is applied to three arguments* then it will guarantee to+    call its first argument at most once, and to call the result of that at+    most once. But if f has fewer than three arguments, all bets are off; e.g.++          map (f (\x y. expensive) e2) xs++    Here the \x y abstraction may be called many times (once for each element of+    xs) so we should not mark x and y as one-shot. But if it was++          map (f (\x y. expensive) 3 2) xs++    then the first argument of f will be called at most once.++    The one-shot info, derived from f's strictness signature, is+    computed by 'argsOneShots', called in occAnalApp.++A': Non-obviously saturated applications: eg    build (f (\x y -> expensive))+    where f is as above.++    In this case, f is only manifestly applied to one argument, so it does not+    look saturated. So by the previous point, we should not use its strictness+    signature to learn about the one-shotness of \x y. But in this case we can:+    build is fully applied, so we may use its strictness signature; and from+    that we learn that build calls its argument with two arguments *at most once*.++    So there is really only one call to f, and it will have three arguments. In+    that sense, f is saturated, and we may proceed as described above.++    Hence the computation of 'guaranteed_val_args' in occAnalApp, using+    '(occ_one_shots env)'.  See also #13227, comment:9++B:  Let-bindings:  eg   let f = \c. let ... in \n -> blah+                        in (build f, build f)++    Propagate one-shot info from the demanand-info on 'f' to the+    lambdas in its RHS (which may not be syntactically at the top)++    This information must have come from a previous run of the demanand+    analyser.++Previously, the demand analyser would *also* set the one-shot information, but+that code was buggy (see #11770), so doing it only in on place, namely here, is+saner.++Note [OneShots]+~~~~~~~~~~~~~~~+When analysing an expression, the occ_one_shots argument contains information+about how the function is being used. The length of the list indicates+how many arguments will eventually be passed to the analysed expression,+and the OneShotInfo indicates whether this application is once or multiple times.++Example:++ Context of f                occ_one_shots when analysing f++ f 1 2                       [OneShot, OneShot]+ map (f 1)                   [OneShot, NoOneShotInfo]+ build f                     [OneShot, OneShot]+ f 1 2 `seq` f 2 1           [NoOneShotInfo, OneShot]++Note [Binders in case alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+    case x of y { (a,b) -> f y }+We treat 'a', 'b' as dead, because they don't physically occur in the+case alternative.  (Indeed, a variable is dead iff it doesn't occur in+its scope in the output of OccAnal.)  It really helps to know when+binders are unused.  See esp the call to isDeadBinder in+Simplify.mkDupableAlt++In this example, though, the Simplifier will bring 'a' and 'b' back to+life, because it binds 'y' to (a,b) (imagine got inlined and+scrutinised y).+-}++occAnalLamOrRhs :: OccEnv -> [CoreBndr] -> CoreExpr+                -> (UsageDetails, [CoreBndr], CoreExpr)+-- Tags the returned binders with their OccInfo, but does+-- not do any markInsideLam to the returned usage details+occAnalLamOrRhs env [] body+  = case occAnal env body of (body_usage, body') -> (body_usage, [], body')+      -- RHS of thunk or nullary join point++occAnalLamOrRhs env (bndr:bndrs) body+  | isTyVar bndr+  = -- Important: Keep the environment so that we don't inline into an RHS like+    --   \(@ x) -> C @x (f @x)+    -- (see the beginning of Note [Cascading inlines]).+    case occAnalLamOrRhs env bndrs body of+      (body_usage, bndrs', body') -> (body_usage, bndr:bndrs', body')++occAnalLamOrRhs env binders body+  = case occAnal env_body body of { (body_usage, body') ->+    let+        (final_usage, tagged_binders) = tagLamBinders body_usage binders'+                      -- Use binders' to put one-shot info on the lambdas+    in+    (final_usage, tagged_binders, body') }+  where+    env1 = env `addInScope` binders+    (env_body, binders') = oneShotGroup env1 binders++occAnalAlt :: OccEnv -> CoreAlt -> (UsageDetails, Alt IdWithOccInfo)+occAnalAlt env (con, bndrs, rhs)+  = case occAnal (env `addInScope` bndrs) rhs of { (rhs_usage1, rhs1) ->+    let+      (alt_usg, tagged_bndrs) = tagLamBinders rhs_usage1 bndrs+    in                          -- See Note [Binders in case alternatives]+    (alt_usg, (con, tagged_bndrs, rhs1)) }+++{-+************************************************************************+*                                                                      *+                    OccEnv+*                                                                      *+************************************************************************+-}++data OccEnv+  = OccEnv { occ_encl       :: !OccEncl      -- Enclosing context information+           , occ_one_shots  :: !OneShots     -- See Note [OneShots]+           , occ_unf_act    :: Id -> Bool          -- Which Id unfoldings are active+           , occ_rule_act   :: Activation -> Bool  -- Which rules are active+             -- See Note [Finding rule RHS free vars]++           -- See Note [The binder-swap substitution]+           , occ_bs_env  :: VarEnv (OutExpr, OutId)+           , occ_bs_rng  :: VarSet   -- Vars free in the range of occ_bs_env+                   -- Domain is Global and Local Ids+                   -- Range is just Local Ids+    }+++-----------------------------+-- OccEncl is used to control whether to inline into constructor arguments+-- For example:+--      x = (p,q)               -- Don't inline p or q+--      y = /\a -> (p a, q a)   -- Still don't inline p or q+--      z = f (p,q)             -- Do inline p,q; it may make a rule fire+-- So OccEncl tells enough about the context to know what to do when+-- we encounter a constructor application or PAP.+--+-- OccScrut is used to set the "interesting context" field of OncOcc++data OccEncl+  = OccRhs         -- RHS of let(rec), albeit perhaps inside a type lambda+                   -- Don't inline into constructor args here++  | OccScrut       -- Scrutintee of a case+                   -- Can inline into constructor args++  | OccVanilla     -- Argument of function, body of lambda, etc+                   -- Do inline into constructor args here++instance Outputable OccEncl where+  ppr OccRhs     = text "occRhs"+  ppr OccScrut   = text "occScrut"+  ppr OccVanilla = text "occVanilla"++-- See note [OneShots]+type OneShots = [OneShotInfo]++initOccEnv :: OccEnv+initOccEnv+  = OccEnv { occ_encl      = OccVanilla+           , occ_one_shots = []++                 -- To be conservative, we say that all+                 -- inlines and rules are active+           , occ_unf_act   = \_ -> True+           , occ_rule_act  = \_ -> True++           , occ_bs_env = emptyVarEnv+           , occ_bs_rng = emptyVarSet }++noBinderSwaps :: OccEnv -> Bool+noBinderSwaps (OccEnv { occ_bs_env = bs_env }) = isEmptyVarEnv bs_env++scrutCtxt :: OccEnv -> [CoreAlt] -> OccEnv+scrutCtxt env alts+  | interesting_alts =  env { occ_encl = OccScrut,   occ_one_shots = [] }+  | otherwise        =  env { occ_encl = OccVanilla, occ_one_shots = [] }+  where+    interesting_alts = case alts of+                         []    -> False+                         [alt] -> not (isDefaultAlt alt)+                         _     -> True+     -- 'interesting_alts' is True if the case has at least one+     -- non-default alternative.  That in turn influences+     -- pre/postInlineUnconditionally.  Grep for "occ_int_cxt"!++rhsCtxt :: OccEnv -> OccEnv+rhsCtxt env = env { occ_encl = OccRhs, occ_one_shots = [] }++argCtxt :: OccEnv -> [OneShots] -> (OccEnv, [OneShots])+argCtxt env []+  = (env { occ_encl = OccVanilla, occ_one_shots = [] }, [])+argCtxt env (one_shots:one_shots_s)+  = (env { occ_encl = OccVanilla, occ_one_shots = one_shots }, one_shots_s)++isRhsEnv :: OccEnv -> Bool+isRhsEnv (OccEnv { occ_encl = cxt }) = case cxt of+                                          OccRhs -> True+                                          _      -> False++addInScope :: OccEnv -> [Var] -> OccEnv+-- See Note [The binder-swap substitution]+addInScope env@(OccEnv { occ_bs_env = swap_env, occ_bs_rng = rng_vars }) bndrs+  | any (`elemVarSet` rng_vars) bndrs = env { occ_bs_env = emptyVarEnv, occ_bs_rng = emptyVarSet }+  | otherwise                         = env { occ_bs_env = swap_env `delVarEnvList` bndrs }++oneShotGroup :: OccEnv -> [CoreBndr]+             -> ( OccEnv+                , [CoreBndr] )+        -- The result binders have one-shot-ness set that they might not have had originally.+        -- This happens in (build (\c n -> e)).  Here the occurrence analyser+        -- linearity context knows that c,n are one-shot, and it records that fact in+        -- the binder. This is useful to guide subsequent float-in/float-out transformations++oneShotGroup env@(OccEnv { occ_one_shots = ctxt }) bndrs+  = go ctxt bndrs []+  where+    go ctxt [] rev_bndrs+      = ( env { occ_one_shots = ctxt, occ_encl = OccVanilla }+        , reverse rev_bndrs )++    go [] bndrs rev_bndrs+      = ( env { occ_one_shots = [], occ_encl = OccVanilla }+        , reverse rev_bndrs ++ bndrs )++    go ctxt@(one_shot : ctxt') (bndr : bndrs) rev_bndrs+      | isId bndr = go ctxt' bndrs (bndr': rev_bndrs)+      | otherwise = go ctxt  bndrs (bndr : rev_bndrs)+      where+        bndr' = updOneShotInfo bndr one_shot+               -- Use updOneShotInfo, not setOneShotInfo, as pre-existing+               -- one-shot info might be better than what we can infer, e.g.+               -- due to explicit use of the magic 'oneShot' function.+               -- See Note [The oneShot function]+++markJoinOneShots :: Maybe JoinArity -> [Var] -> [Var]+-- Mark the lambdas of a non-recursive join point as one-shot.+-- This is good to prevent gratuitous float-out etc+markJoinOneShots mb_join_arity bndrs+  = case mb_join_arity of+      Nothing -> bndrs+      Just n  -> go n bndrs+ where+   go 0 bndrs  = bndrs+   go _ []     = [] -- This can legitimately happen.+                    -- e.g.    let j = case ... in j True+                    -- This will become an arity-1 join point after the+                    -- simplifier has eta-expanded it; but it may not have+                    -- enough lambdas /yet/. (Lint checks that JoinIds do+                    -- have enough lambdas.)+   go n (b:bs) = b' : go (n-1) bs+     where+       b' | isId b    = setOneShotLambda b+          | otherwise = b++addAppCtxt :: OccEnv -> [Arg CoreBndr] -> OccEnv+addAppCtxt env@(OccEnv { occ_one_shots = ctxt }) args+  = env { occ_one_shots = replicate (valArgCount args) OneShotLam ++ ctxt }++transClosureFV :: UniqFM VarSet -> UniqFM VarSet+-- If (f,g), (g,h) are in the input, then (f,h) is in the output+--                                   as well as (f,g), (g,h)+transClosureFV env+  | no_change = env+  | otherwise = transClosureFV (listToUFM new_fv_list)+  where+    (no_change, new_fv_list) = mapAccumL bump True (nonDetUFMToList env)+      -- It's OK to use nonDetUFMToList here because we'll forget the+      -- ordering by creating a new set with listToUFM+    bump no_change (b,fvs)+      | no_change_here = (no_change, (b,fvs))+      | otherwise      = (False,     (b,new_fvs))+      where+        (new_fvs, no_change_here) = extendFvs env fvs++-------------+extendFvs_ :: UniqFM VarSet -> VarSet -> VarSet+extendFvs_ env s = fst (extendFvs env s)   -- Discard the Bool flag++extendFvs :: UniqFM VarSet -> VarSet -> (VarSet, Bool)+-- (extendFVs env s) returns+--     (s `union` env(s), env(s) `subset` s)+extendFvs env s+  | isNullUFM env+  = (s, True)+  | otherwise+  = (s `unionVarSet` extras, extras `subVarSet` s)+  where+    extras :: VarSet    -- env(s)+    extras = nonDetFoldUFM unionVarSet emptyVarSet $+      -- It's OK to use nonDetFoldUFM here because unionVarSet commutes+             intersectUFM_C (\x _ -> x) env (getUniqSet s)++{-+************************************************************************+*                                                                      *+                    Binder swap+*                                                                      *+************************************************************************++Note [Binder swap]+~~~~~~~~~~~~~~~~~~+The "binder swap" transformation swaps occurrence of the+scrutinee of a case for occurrences of the case-binder:++ (1)  case x of b { pi -> ri }+         ==>+      case x of b { pi -> ri[b/x] }++ (2)  case (x |> co) of b { pi -> ri }+        ==>+      case (x |> co) of b { pi -> ri[b |> sym co/x] }++The substitution ri[b/x] etc is done by the occurrence analyser.+See Note [The binder-swap substitution].++There are two reasons for making this swap:++(A) It reduces the number of occurrences of the scrutinee, x.+    That in turn might reduce its occurrences to one, so we+    can inline it and save an allocation.  E.g.+      let x = factorial y in case x of b { I# v -> ...x... }+    If we replace 'x' by 'b' in the alternative we get+      let x = factorial y in case x of b { I# v -> ...b... }+    and now we can inline 'x', thus+      case (factorial y) of b { I# v -> ...b... }++(B) The case-binder b has unfolding information; in the+    example above we know that b = I# v. That in turn allows+    nested cases to simplify.  Consider+       case x of b { I# v ->+       ...(case x of b2 { I# v2 -> rhs })...+    If we replace 'x' by 'b' in the alternative we get+       case x of b { I# v ->+       ...(case b of b2 { I# v2 -> rhs })...+    and now it is trivial to simplify the inner case:+       case x of b { I# v ->+       ...(let b2 = b in rhs)...++    The same can happen even if the scrutinee is a variable+    with a cast: see Note [Case of cast]++The reason for doing these transformations /here in the occurrence+analyser/ is because it allows us to adjust the OccInfo for 'x' and+'b' as we go.++  * Suppose the only occurrences of 'x' are the scrutinee and in the+    ri; then this transformation makes it occur just once, and hence+    get inlined right away.++  * If instead the Simplifier replaces occurrences of x with+    occurrences of b, that will mess up b's occurrence info. That in+    turn might have consequences.++There is a danger though.  Consider+      let v = x +# y+      in case (f v) of w -> ...v...v...+And suppose that (f v) expands to just v.  Then we'd like to+use 'w' instead of 'v' in the alternative.  But it may be too+late; we may have substituted the (cheap) x+#y for v in the+same simplifier pass that reduced (f v) to v.++I think this is just too bad.  CSE will recover some of it.++Note [The binder-swap substitution]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The binder-swap is implemented by the occ_bs_env field of OccEnv.+Given    case x |> co of b { alts }+we add [x :-> (b |> sym co)] to the occ_bs_env environment; this is+done by addBndrSwap.  Then, at an occurrence of a variable, we look+up in the occ_bs_env to perform the swap.  See occAnalApp.++Some tricky corners:++* We do the substitution before gathering occurrence info. So in+  the above example, an occurrence of x turns into an occurrence+  of b, and that's what we gather in the UsageDetails.  It's as+  if the binder-swap occurred before occurrence analysis.++* We need care when shadowing.  Suppose [x :-> b] is in occ_bs_env,+  and we encounter:+     - \x. blah+       Here we want to delete the x-binding from occ_bs_env++     - \b. blah+       This is harder: we really want to delete all bindings that+       have 'b' free in the range.  That is a bit tiresome to implement,+       so we compromise.  We keep occ_bs_rng, which is the set of+       free vars of rng(occc_bs_env).  If a binder shadows any of these+       variables, we discard all of occ_bs_env.  Safe, if a bit+       brutal.  NB, however: the simplifer de-shadows the code, so the+       next time around this won't happen.++  These checks are implemented in addInScope.++* The occurrence analyser itself does /not/ do cloning. It could, in+  principle, but it'd make it a bit more complicated and there is no+  great benefit. The simplifer uses cloning to get a no-shadowing+  situation, the care-when-shadowing behaviour above isn't needed for+  long.++* The domain of occ_bs_env can include GlobaIds.  Eg+      case M.foo of b { alts }+  We extend occ_bs_env with [M.foo :-> b].  That's fine.++* We have to apply the substitution uniformly, including to rules and+  unfoldings.++Historical note+---------------+We used to do the binder-swap transformation by introducing+a proxy let-binding, thus;++   case x of b { pi -> ri }+      ==>+   case x of b { pi -> let x = b in ri }++But that had two problems:++1. If 'x' is an imported GlobalId, we'd end up with a GlobalId+   on the LHS of a let-binding which isn't allowed.  We worked+   around this for a while by "localising" x, but it turned+   out to be very painful #16296,++2. In CorePrep we use the occurrence analyser to do dead-code+   elimination (see Note [Dead code in CorePrep]).  But that+   occasionally led to an unlifted let-binding+       case x of b { DEFAULT -> let x::Int# = b in ... }+   which disobeys one of CorePrep's output invariants (no unlifted+   let-bindings) -- see #5433.++Doing a substitution (via occ_bs_env) is much better.++Note [Case of cast]+~~~~~~~~~~~~~~~~~~~+Consider        case (x `cast` co) of b { I# ->+                ... (case (x `cast` co) of {...}) ...+We'd like to eliminate the inner case.  That is the motivation for+equation (2) in Note [Binder swap].  When we get to the inner case, we+inline x, cancel the casts, and away we go.++Note [Zap case binders in proxy bindings]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+From the original+     case x of cb(dead) { p -> ...x... }+we will get+     case x of cb(live) { p -> ...cb... }++Core Lint never expects to find an *occurrence* of an Id marked+as Dead, so we must zap the OccInfo on cb before making the+binding x = cb.  See #5028.++NB: the OccInfo on /occurrences/ really doesn't matter much; the simplifier+doesn't use it. So this is only to satisfy the perhaps-over-picky Lint.++Historical note [no-case-of-case]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We *used* to suppress the binder-swap in case expressions when+-fno-case-of-case is on.  Old remarks:+    "This happens in the first simplifier pass,+    and enhances full laziness.  Here's the bad case:+            f = \ y -> ...(case x of I# v -> ...(case x of ...) ... )+    If we eliminate the inner case, we trap it inside the I# v -> arm,+    which might prevent some full laziness happening.  I've seen this+    in action in spectral/cichelli/Prog.hs:+             [(m,n) | m <- [1..max], n <- [1..max]]+    Hence the check for NoCaseOfCase."+However, now the full-laziness pass itself reverses the binder-swap, so this+check is no longer necessary.++Historical note [Suppressing the case binder-swap]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+This old note describes a problem that is also fixed by doing the+binder-swap in OccAnal:++    There is another situation when it might make sense to suppress the+    case-expression binde-swap. If we have++        case x of w1 { DEFAULT -> case x of w2 { A -> e1; B -> e2 }+                       ...other cases .... }++    We'll perform the binder-swap for the outer case, giving++        case x of w1 { DEFAULT -> case w1 of w2 { A -> e1; B -> e2 }+                       ...other cases .... }++    But there is no point in doing it for the inner case, because w1 can't+    be inlined anyway.  Furthermore, doing the case-swapping involves+    zapping w2's occurrence info (see paragraphs that follow), and that+    forces us to bind w2 when doing case merging.  So we get++        case x of w1 { A -> let w2 = w1 in e1+                       B -> let w2 = w1 in e2+                       ...other cases .... }++    This is plain silly in the common case where w2 is dead.++    Even so, I can't see a good way to implement this idea.  I tried+    not doing the binder-swap if the scrutinee was already evaluated+    but that failed big-time:++            data T = MkT !Int++            case v of w  { MkT x ->+            case x of x1 { I# y1 ->+            case x of x2 { I# y2 -> ...++    Notice that because MkT is strict, x is marked "evaluated".  But to+    eliminate the last case, we must either make sure that x (as well as+    x1) has unfolding MkT y1.  The straightforward thing to do is to do+    the binder-swap.  So this whole note is a no-op.++It's fixed by doing the binder-swap in OccAnal because we can do the+binder-swap unconditionally and still get occurrence analysis+information right.+-}++addBndrSwap :: OutExpr -> Id -> OccEnv -> OccEnv+-- See Note [The binder-swap substitution]+addBndrSwap scrut case_bndr+            env@(OccEnv { occ_bs_env = swap_env, occ_bs_rng = rng_vars })+  | Just (v, rhs) <- try_swap (stripTicksTopE (const True) scrut)+  = env { occ_bs_env = extendVarEnv swap_env v (rhs, case_bndr')+        , occ_bs_rng = rng_vars `unionVarSet` exprFreeVars rhs }++  | otherwise+  = env+  where+    try_swap :: OutExpr -> Maybe (OutVar, OutExpr)+    try_swap (Var v)           = Just (v, Var case_bndr')+    try_swap (Cast (Var v) co) = Just (v, Cast (Var case_bndr') (mkSymCo co))+                        -- See Note [Case of cast]+    try_swap _ = Nothing++    case_bndr' = zapIdOccInfo case_bndr+                 -- See Note [Zap case binders in proxy bindings]++{-+************************************************************************+*                                                                      *+\subsection[OccurAnal-types]{OccEnv}+*                                                                      *+************************************************************************++Note [UsageDetails and zapping]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+On many occasions, we must modify all gathered occurrence data at once. For+instance, all occurrences underneath a (non-one-shot) lambda set the+'occ_in_lam' flag to become 'True'. We could use 'mapVarEnv' to do this, but+that takes O(n) time and we will do this often---in particular, there are many+places where tail calls are not allowed, and each of these causes all variables+to get marked with 'NoTailCallInfo'.++Instead of relying on `mapVarEnv`, then, we carry three 'IdEnv's around along+with the 'OccInfoEnv'. Each of these extra environments is a "zapped set"+recording which variables have been zapped in some way. Zapping all occurrence+info then simply means setting the corresponding zapped set to the whole+'OccInfoEnv', a fast O(1) operation.+-}++type OccInfoEnv = IdEnv OccInfo -- A finite map from ids to their usage+                -- INVARIANT: never IAmDead+                -- (Deadness is signalled by not being in the map at all)++type ZappedSet = OccInfoEnv -- Values are ignored++data UsageDetails+  = UD { ud_env       :: !OccInfoEnv+       , ud_z_many    :: ZappedSet   -- apply 'markMany' to these+       , ud_z_in_lam  :: ZappedSet   -- apply 'markInsideLam' to these+       , ud_z_no_tail :: ZappedSet } -- apply 'markNonTail' to these+  -- INVARIANT: All three zapped sets are subsets of the OccInfoEnv++instance Outputable UsageDetails where+  ppr ud = ppr (ud_env (flattenUsageDetails ud))++-------------------+-- UsageDetails API++andUDs, orUDs+        :: UsageDetails -> UsageDetails -> UsageDetails+andUDs = combineUsageDetailsWith addOccInfo+orUDs  = combineUsageDetailsWith orOccInfo++mkOneOcc ::Id -> InterestingCxt -> JoinArity -> UsageDetails+mkOneOcc id int_cxt arity+  | isLocalId id+  = emptyDetails { ud_env = unitVarEnv id occ_info }+  | otherwise+  = emptyDetails+  where+    occ_info = OneOcc { occ_in_lam  = NotInsideLam+                      , occ_one_br  = InOneBranch+                      , occ_int_cxt = int_cxt+                      , occ_tail    = AlwaysTailCalled arity }++addManyOccId :: UsageDetails -> Id -> UsageDetails+-- Add the non-committal (id :-> noOccInfo) to the usage details+addManyOccId ud id = ud { ud_env = extendVarEnv (ud_env ud) id noOccInfo }++-- Add several occurrences, assumed not to be tail calls+addManyOcc :: Var -> UsageDetails -> UsageDetails+addManyOcc v u | isId v    = addManyOccId u v+               | otherwise = u+        -- Give a non-committal binder info (i.e noOccInfo) because+        --   a) Many copies of the specialised thing can appear+        --   b) We don't want to substitute a BIG expression inside a RULE+        --      even if that's the only occurrence of the thing+        --      (Same goes for INLINE.)++addManyOccs :: UsageDetails -> VarSet -> UsageDetails+addManyOccs usage id_set = nonDetFoldUniqSet addManyOcc usage id_set+  -- It's OK to use nonDetFoldUFM here because addManyOcc commutes++delDetails :: UsageDetails -> Id -> UsageDetails+delDetails ud bndr+  = ud `alterUsageDetails` (`delVarEnv` bndr)++delDetailsList :: UsageDetails -> [Id] -> UsageDetails+delDetailsList ud bndrs+  = ud `alterUsageDetails` (`delVarEnvList` bndrs)++emptyDetails :: UsageDetails+emptyDetails = UD { ud_env       = emptyVarEnv+                  , ud_z_many    = emptyVarEnv+                  , ud_z_in_lam  = emptyVarEnv+                  , ud_z_no_tail = emptyVarEnv }++isEmptyDetails :: UsageDetails -> Bool+isEmptyDetails = isEmptyVarEnv . ud_env++markAllMany, markAllInsideLam, markAllNonTail, markAllManyNonTail+  :: UsageDetails -> UsageDetails+markAllMany          ud = ud { ud_z_many    = ud_env ud }+markAllInsideLam     ud = ud { ud_z_in_lam  = ud_env ud }+markAllNonTail ud = ud { ud_z_no_tail = ud_env ud }++markAllInsideLamIf, markAllNonTailIf :: Bool -> UsageDetails -> UsageDetails++markAllInsideLamIf  True  ud = markAllInsideLam ud+markAllInsideLamIf  False ud = ud++markAllNonTailIf True  ud = markAllNonTail ud+markAllNonTailIf False ud = ud+++markAllManyNonTail = markAllMany . markAllNonTail -- effectively sets to noOccInfo++markAllManyNonTailIf :: Bool              -- If this is true+             -> UsageDetails      -- Then do markAllManyNonTail on this+             -> UsageDetails+markAllManyNonTailIf True  uds = markAllManyNonTail uds+markAllManyNonTailIf False uds = uds++lookupDetails :: UsageDetails -> Id -> OccInfo+lookupDetails ud id+  | isCoVar id  -- We do not currently gather occurrence info (from types)+  = noOccInfo   -- for CoVars, so we must conservatively mark them as used+                -- See Note [DoO not mark CoVars as dead]+  | otherwise+  = case lookupVarEnv (ud_env ud) id of+      Just occ -> doZapping ud id occ+      Nothing  -> IAmDead++usedIn :: Id -> UsageDetails -> Bool+v `usedIn` ud = isExportedId v || v `elemVarEnv` ud_env ud++udFreeVars :: VarSet -> UsageDetails -> VarSet+-- Find the subset of bndrs that are mentioned in uds+udFreeVars bndrs ud = restrictUniqSetToUFM bndrs (ud_env ud)++{- Note [Do not mark CoVars as dead]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+It's obviously wrong to mark CoVars as dead if they are used.+Currently we don't traverse types to gather usase info for CoVars,+so we had better treat them as having noOccInfo.++This showed up in #15696 we had something like+  case eq_sel d of co -> ...(typeError @(...co...) "urk")...++Then 'd' was substituted by a dictionary, so the expression+simpified to+  case (Coercion <blah>) of co -> ...(typeError @(...co...) "urk")...++But then the "drop the case altogether" equation of rebuildCase+thought that 'co' was dead, and discarded the entire case. Urk!++I have no idea how we managed to avoid this pitfall for so long!+-}++-------------------+-- Auxiliary functions for UsageDetails implementation++combineUsageDetailsWith :: (OccInfo -> OccInfo -> OccInfo)+                        -> UsageDetails -> UsageDetails -> UsageDetails+combineUsageDetailsWith plus_occ_info ud1 ud2+  | isEmptyDetails ud1 = ud2+  | isEmptyDetails ud2 = ud1+  | otherwise+  = UD { ud_env       = plusVarEnv_C plus_occ_info (ud_env ud1) (ud_env ud2)+       , ud_z_many    = plusVarEnv (ud_z_many    ud1) (ud_z_many    ud2)+       , ud_z_in_lam  = plusVarEnv (ud_z_in_lam  ud1) (ud_z_in_lam  ud2)+       , ud_z_no_tail = plusVarEnv (ud_z_no_tail ud1) (ud_z_no_tail ud2) }++doZapping :: UsageDetails -> Var -> OccInfo -> OccInfo+doZapping ud var occ+  = doZappingByUnique ud (varUnique var) occ++doZappingByUnique :: UsageDetails -> Unique -> OccInfo -> OccInfo+doZappingByUnique (UD { ud_z_many = many+                      , ud_z_in_lam = in_lam+                      , ud_z_no_tail = no_tail })+                  uniq occ+  = occ2+  where+    occ1 | uniq `elemVarEnvByKey` many    = markMany occ+         | uniq `elemVarEnvByKey` in_lam  = markInsideLam occ+         | otherwise                      = occ+    occ2 | uniq `elemVarEnvByKey` no_tail = markNonTail occ1+         | otherwise                      = occ1++alterZappedSets :: UsageDetails -> (ZappedSet -> ZappedSet) -> UsageDetails+alterZappedSets ud f+  = ud { ud_z_many    = f (ud_z_many    ud)+       , ud_z_in_lam  = f (ud_z_in_lam  ud)+       , ud_z_no_tail = f (ud_z_no_tail ud) }++alterUsageDetails :: UsageDetails -> (OccInfoEnv -> OccInfoEnv) -> UsageDetails+alterUsageDetails ud f+  = ud { ud_env = f (ud_env ud) } `alterZappedSets` f++flattenUsageDetails :: UsageDetails -> UsageDetails+flattenUsageDetails ud+  = ud { ud_env = mapUFM_Directly (doZappingByUnique ud) (ud_env ud) }+      `alterZappedSets` const emptyVarEnv++-------------------+-- See Note [Adjusting right-hand sides]+adjustRhsUsage :: Maybe JoinArity -> RecFlag+               -> [CoreBndr]     -- Outer lambdas, AFTER occ anal+               -> UsageDetails   -- From body of lambda+               -> UsageDetails+adjustRhsUsage mb_join_arity rec_flag bndrs usage+  = markAllInsideLamIf     (not one_shot)   $+    markAllNonTailIf (not exact_join) $+    usage+  where+    one_shot = case mb_join_arity of+                 Just join_arity+                   | isRec rec_flag -> False+                   | otherwise      -> all isOneShotBndr (drop join_arity bndrs)+                 Nothing            -> all isOneShotBndr bndrs++    exact_join = exactJoin mb_join_arity bndrs++exactJoin :: Maybe JoinArity -> [a] -> Bool+exactJoin Nothing           _    = False+exactJoin (Just join_arity) args = args `lengthIs` join_arity+  -- Remember join_arity includes type binders++type IdWithOccInfo = Id++tagLamBinders :: UsageDetails          -- Of scope+              -> [Id]                  -- Binders+              -> (UsageDetails,        -- Details with binders removed+                 [IdWithOccInfo])    -- Tagged binders+tagLamBinders usage binders+  = usage' `seq` (usage', bndrs')+  where+    (usage', bndrs') = mapAccumR tagLamBinder usage binders++tagLamBinder :: UsageDetails       -- Of scope+             -> Id                 -- Binder+             -> (UsageDetails,     -- Details with binder removed+                 IdWithOccInfo)    -- Tagged binders+-- Used for lambda and case binders+-- It copes with the fact that lambda bindings can have a+-- stable unfolding, used for join points+tagLamBinder usage bndr+  = (usage2, bndr')+  where+        occ    = lookupDetails usage bndr+        bndr'  = setBinderOcc (markNonTail occ) bndr+                   -- Don't try to make an argument into a join point+        usage1 = usage `delDetails` bndr+        usage2 | isId bndr = addManyOccs usage1 (idUnfoldingVars bndr)+                               -- This is effectively the RHS of a+                               -- non-join-point binding, so it's okay to use+                               -- addManyOccsSet, which assumes no tail calls+               | otherwise = usage1++tagNonRecBinder :: TopLevelFlag           -- At top level?+                -> UsageDetails           -- Of scope+                -> CoreBndr               -- Binder+                -> (UsageDetails,         -- Details with binder removed+                    IdWithOccInfo)        -- Tagged binder++tagNonRecBinder lvl usage binder+ = let+     occ     = lookupDetails usage binder+     will_be_join = decideJoinPointHood lvl usage [binder]+     occ'    | will_be_join = -- must already be marked AlwaysTailCalled+                              ASSERT(isAlwaysTailCalled occ) occ+             | otherwise    = markNonTail occ+     binder' = setBinderOcc occ' binder+     usage'  = usage `delDetails` binder+   in+   usage' `seq` (usage', binder')++tagRecBinders :: TopLevelFlag           -- At top level?+              -> UsageDetails           -- Of body of let ONLY+              -> [(CoreBndr,            -- Binder+                   UsageDetails,        -- RHS usage details+                   [CoreBndr])]         -- Lambdas in new RHS+              -> (UsageDetails,         -- Adjusted details for whole scope,+                                        -- with binders removed+                  [IdWithOccInfo])      -- Tagged binders+-- Substantially more complicated than non-recursive case. Need to adjust RHS+-- details *before* tagging binders (because the tags depend on the RHSes).+tagRecBinders lvl body_uds triples+ = let+     (bndrs, rhs_udss, _) = unzip3 triples++     -- 1. Determine join-point-hood of whole group, as determined by+     --    the *unadjusted* usage details+     unadj_uds     = foldr andUDs body_uds rhs_udss+     will_be_joins = decideJoinPointHood lvl unadj_uds bndrs++     -- 2. Adjust usage details of each RHS, taking into account the+     --    join-point-hood decision+     rhs_udss' = map adjust triples+     adjust (bndr, rhs_uds, rhs_bndrs)+       = adjustRhsUsage mb_join_arity Recursive rhs_bndrs rhs_uds+       where+         -- Can't use willBeJoinId_maybe here because we haven't tagged the+         -- binder yet (the tag depends on these adjustments!)+         mb_join_arity+           | will_be_joins+           , let occ = lookupDetails unadj_uds bndr+           , AlwaysTailCalled arity <- tailCallInfo occ+           = Just arity+           | otherwise+           = ASSERT(not will_be_joins) -- Should be AlwaysTailCalled if+             Nothing                   -- we are making join points!++     -- 3. Compute final usage details from adjusted RHS details+     adj_uds   = foldr andUDs body_uds rhs_udss'++     -- 4. Tag each binder with its adjusted details+     bndrs'    = [ setBinderOcc (lookupDetails adj_uds bndr) bndr+                 | bndr <- bndrs ]++     -- 5. Drop the binders from the adjusted details and return+     usage'    = adj_uds `delDetailsList` bndrs+   in+   (usage', bndrs')++setBinderOcc :: OccInfo -> CoreBndr -> CoreBndr+setBinderOcc occ_info bndr+  | isTyVar bndr      = bndr+  | isExportedId bndr = if isManyOccs (idOccInfo bndr)+                          then bndr+                          else setIdOccInfo bndr noOccInfo+            -- Don't use local usage info for visible-elsewhere things+            -- BUT *do* erase any IAmALoopBreaker annotation, because we're+            -- about to re-generate it and it shouldn't be "sticky"++  | otherwise = setIdOccInfo bndr occ_info++-- | Decide whether some bindings should be made into join points or not.+-- Returns `False` if they can't be join points. Note that it's an+-- all-or-nothing decision, as if multiple binders are given, they're+-- assumed to be mutually recursive.+--+-- It must, however, be a final decision. If we say "True" for 'f',+-- and then subsequently decide /not/ make 'f' into a join point, then+-- the decision about another binding 'g' might be invalidated if (say)+-- 'f' tail-calls 'g'.+--+-- See Note [Invariants on join points] in GHC.Core.+decideJoinPointHood :: TopLevelFlag -> UsageDetails+                    -> [CoreBndr]+                    -> Bool+decideJoinPointHood TopLevel _ _+  = False+decideJoinPointHood NotTopLevel usage bndrs+  | isJoinId (head bndrs)+  = WARN(not all_ok, text "OccurAnal failed to rediscover join point(s):" <+>+                       ppr bndrs)+    all_ok+  | otherwise+  = all_ok+  where+    -- See Note [Invariants on join points]; invariants cited by number below.+    -- Invariant 2 is always satisfiable by the simplifier by eta expansion.+    all_ok = -- Invariant 3: Either all are join points or none are+             all ok bndrs++    ok bndr+      | -- Invariant 1: Only tail calls, all same join arity+        AlwaysTailCalled arity <- tailCallInfo (lookupDetails usage bndr)++      , -- Invariant 1 as applied to LHSes of rules+        all (ok_rule arity) (idCoreRules bndr)++        -- Invariant 2a: stable unfoldings+        -- See Note [Join points and INLINE pragmas]+      , ok_unfolding arity (realIdUnfolding bndr)++        -- Invariant 4: Satisfies polymorphism rule+      , isValidJoinPointType arity (idType bndr)+      = True++      | otherwise+      = False++    ok_rule _ BuiltinRule{} = False -- only possible with plugin shenanigans+    ok_rule join_arity (Rule { ru_args = args })+      = args `lengthIs` join_arity+        -- Invariant 1 as applied to LHSes of rules++    -- ok_unfolding returns False if we should /not/ convert a non-join-id+    -- into a join-id, even though it is AlwaysTailCalled+    ok_unfolding join_arity (CoreUnfolding { uf_src = src, uf_tmpl = rhs })+      = not (isStableSource src && join_arity > joinRhsArity rhs)+    ok_unfolding _ (DFunUnfolding {})+      = False+    ok_unfolding _ _+      = True++willBeJoinId_maybe :: CoreBndr -> Maybe JoinArity+willBeJoinId_maybe bndr+  = case tailCallInfo (idOccInfo bndr) of+      AlwaysTailCalled arity -> Just arity+      _                      -> isJoinId_maybe bndr+++{- Note [Join points and INLINE pragmas]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+   f x = let g = \x. not  -- Arity 1+             {-# INLINE g #-}+         in case x of+              A -> g True True+              B -> g True False+              C -> blah2++Here 'g' is always tail-called applied to 2 args, but the stable+unfolding captured by the INLINE pragma has arity 1.  If we try to+convert g to be a join point, its unfolding will still have arity 1+(since it is stable, and we don't meddle with stable unfoldings), and+Lint will complain (see Note [Invariants on join points], (2a), in+GHC.Core.  #13413.++Moreover, since g is going to be inlined anyway, there is no benefit+from making it a join point.++If it is recursive, and uselessly marked INLINE, this will stop us+making it a join point, which is annoying.  But occasionally+(notably in class methods; see Note [Instances and loop breakers] in+GHC.Tc.TyCl.Instance) we mark recursive things as INLINE but the recursion+unravels; so ignoring INLINE pragmas on recursive things isn't good+either.++See Invariant 2a of Note [Invariants on join points] in GHC.Core+++************************************************************************+*                                                                      *+\subsection{Operations over OccInfo}+*                                                                      *+************************************************************************+-}++markMany, markInsideLam, markNonTail :: OccInfo -> OccInfo++markMany IAmDead = IAmDead+markMany occ     = ManyOccs { occ_tail = occ_tail occ }++markInsideLam occ@(OneOcc {}) = occ { occ_in_lam = IsInsideLam }+markInsideLam occ             = occ++markNonTail IAmDead = IAmDead+markNonTail occ     = occ { occ_tail = NoTailCallInfo }++addOccInfo, orOccInfo :: OccInfo -> OccInfo -> OccInfo++addOccInfo a1 a2  = ASSERT( not (isDeadOcc a1 || isDeadOcc a2) )+                    ManyOccs { occ_tail = tailCallInfo a1 `andTailCallInfo`+                                          tailCallInfo a2 }+                                -- Both branches are at least One+                                -- (Argument is never IAmDead)++-- (orOccInfo orig new) is used+-- when combining occurrence info from branches of a case++orOccInfo (OneOcc { occ_in_lam = in_lam1, occ_int_cxt = int_cxt1+                  , occ_tail   = tail1 })+          (OneOcc { occ_in_lam = in_lam2, occ_int_cxt = int_cxt2+                  , occ_tail   = tail2 })+  = OneOcc { occ_one_br  = MultipleBranches -- because it occurs in both branches+           , occ_in_lam  = in_lam1 `mappend` in_lam2+           , occ_int_cxt = int_cxt1 `mappend` int_cxt2+           , occ_tail    = tail1 `andTailCallInfo` tail2 }++orOccInfo a1 a2 = ASSERT( not (isDeadOcc a1 || isDeadOcc a2) )+                  ManyOccs { occ_tail = tailCallInfo a1 `andTailCallInfo`+                                        tailCallInfo a2 }++andTailCallInfo :: TailCallInfo -> TailCallInfo -> TailCallInfo+andTailCallInfo info@(AlwaysTailCalled arity1) (AlwaysTailCalled arity2)+  | arity1 == arity2 = info+andTailCallInfo _ _  = NoTailCallInfo
compiler/GHC/Core/PatSyn.hs view
@@ -24,14 +24,14 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core.Type import GHC.Core.TyCo.Ppr import GHC.Types.Name-import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique-import Util+import GHC.Utils.Misc import GHC.Types.Basic import GHC.Types.Var import GHC.Types.FieldLabel@@ -295,12 +295,12 @@  This means that when typechecking an occurrence of P in an expression, we must remember that the builder has this void argument. This is-done by TcPatSyn.patSynBuilderOcc.+done by GHC.Tc.TyCl.PatSyn.patSynBuilderOcc.  Note [Pattern synonyms and the data type Type] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The type of a pattern synonym is of the form (See Note-[Pattern synonym signatures] in TcSigs):+[Pattern synonym signatures] in GHC.Tc.Gen.Sig):      forall univ_tvs. req => forall ex_tvs. prov => ...
compiler/GHC/Core/Ppr.hs view
@@ -17,7 +17,7 @@         pprRules, pprOptCo     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Core import GHC.Core.Stats (exprStats)@@ -33,10 +33,10 @@ import GHC.Core.TyCo.Ppr import GHC.Core.Coercion import GHC.Types.Basic-import Maybes-import Util-import Outputable-import FastString+import GHC.Data.Maybe+import GHC.Utils.Misc+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Types.SrcLoc ( pprUserRealSpan )  {-@@ -123,11 +123,13 @@          , pp_bind          ]   where+    pp_val_bdr = pprPrefixOcc val_bdr+     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)+    pp_normal_bind = hang pp_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@@ -135,7 +137,7 @@       -- an n-argument function).     pp_join_bind join_arity       | bndrs `lengthAtLeast` join_arity-      = hang (ppr val_bdr <+> sep (map (pprBndr LambdaBind) lhs_bndrs))+      = hang (pp_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@@ -164,8 +166,10 @@         -- an atomic value (e.g. function args)  ppr_expr add_par (Var name)- | isJoinId name               = add_par ((text "jump") <+> ppr name)- | otherwise                   = ppr name+ | isJoinId name               = add_par ((text "jump") <+> pp_name)+ | otherwise                   = pp_name+ where+   pp_name = pprPrefixOcc 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@@ -429,7 +433,7 @@ -- 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)+pprIdBndr id = pprPrefixOcc id <+> pprIdBndrInfo (idInfo id)  pprIdBndrInfo :: IdInfo -> SDoc pprIdBndrInfo info@@ -442,7 +446,7 @@     lbv_info  = oneShotInfo info      has_prag  = not (isDefaultInlinePragma prag_info)-    has_occ   = not (isManyOccs occ_info)+    has_occ   = not (isNoOccInfo occ_info)     has_dmd   = not $ isTopDmd dmd_info     has_lbv   = not (hasNoOneShotInfo lbv_info)
compiler/GHC/Core/Predicate.hs view
@@ -28,7 +28,7 @@   DictId, isEvVar, isDictId   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Core.Type import GHC.Core.Class@@ -36,11 +36,11 @@ import GHC.Types.Var import GHC.Core.Coercion -import PrelNames+import GHC.Builtin.Names -import FastString-import Outputable-import Util+import GHC.Data.FastString+import GHC.Utils.Outputable+import GHC.Utils.Misc  import Control.Monad ( guard ) @@ -51,7 +51,7 @@   | EqPred EqRel Type Type   | IrredPred PredType   | ForAllPred [TyVar] [PredType] PredType-     -- ForAllPred: see Note [Quantified constraints] in TcCanonical+     -- ForAllPred: see Note [Quantified constraints] in GHC.Tc.Solver.Canonical   -- NB: There is no TuplePred case   --     Tuple predicates like (Eq a, Ord b) are just treated   --     as ClassPred, as if we had a tuple class with two superclasses@@ -144,7 +144,7 @@ {- Note [Evidence for quantified constraints] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The superclass mechanism in TcCanonical.makeSuperClasses risks+The superclass mechanism in GHC.Tc.Solver.Canonical.makeSuperClasses risks taking a quantified constraint like    (forall a. C a => a ~ b) and generate superclass evidence@@ -153,7 +153,7 @@ This is a funny thing: neither isPredTy nor isCoVarType are true of it.  So we are careful not to generate it in the first place: see Note [Equality superclasses in quantified constraints]-in TcCanonical.+in GHC.Tc.Solver.Canonical. -}  isEvVarType :: Type -> Bool
− compiler/GHC/Core/Rules.hs 
@@ -1,1261 +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 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 GHC.Types.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 GHC.Core.Type as Type-   ( Type, TCvSubst, extendTvSubst, extendCvSubst-   , mkEmptyTCvSubst, substTy )-import TcType           ( tcSplitTyConApp_maybe )-import TysWiredIn       ( anyTypeOfKind )-import GHC.Core.Coercion as Coercion-import GHC.Core.Op.Tidy ( tidyRules )-import GHC.Types.Id-import GHC.Types.Id.Info ( RuleInfo( RuleInfo ) )-import GHC.Types.Var-import GHC.Types.Var.Env-import GHC.Types.Var.Set-import GHC.Types.Name    ( Name, NamedThing(..), nameIsLocalOrFrom )-import GHC.Types.Name.Set-import GHC.Types.Name.Env-import GHC.Types.Unique.FM-import GHC.Core.Unify as Unify ( ruleMatchTyKiX )-import GHC.Types.Basic-import GHC.Driver.Session      ( DynFlags, gopt, targetPlatform )-import GHC.Driver.Flags-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 GHC.Core.Op.Monad.-  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 GHC.Core.Op.Monad, 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 GHC.Core.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 GHC.Core.Op.ConstantFold.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-  = let env = RuleOpts-               { roPlatform = targetPlatform dflags-               , roNumConstantFolding = gopt Opt_NumConstantFolding dflags-               , roExcessRationalPrecision = gopt Opt_ExcessPrecision dflags-               }-    in case match_fn env 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 GHC.Core.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 GHC.Core.Op.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
@@ -10,7 +10,7 @@         megaSeqIdInfo, seqRuleInfo, seqBinds,     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Core import GHC.Types.Id.Info
compiler/GHC/Core/SimpleOpt.hs view
@@ -20,7 +20,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core.Arity( etaExpandToJoinPoint ) @@ -31,7 +31,7 @@ import {-# SOURCE #-} GHC.Core.Unfold( mkUnfolding ) import GHC.Core.Make ( FloatBind(..) ) import GHC.Core.Ppr  ( pprCoreBindings, pprRules )-import GHC.Core.Op.OccurAnal( occurAnalyseExpr, occurAnalysePgm )+import GHC.Core.Opt.OccurAnal( occurAnalyseExpr, occurAnalysePgm ) import GHC.Types.Literal  ( Literal(LitString) ) import GHC.Types.Id import GHC.Types.Id.Info  ( unfoldingInfo, setUnfoldingInfo, setRuleInfo, IdInfo (..) )@@ -45,17 +45,17 @@                             , isInScope, substTyVarBndr, cloneTyVarBndr ) import GHC.Core.Coercion hiding ( substCo, substCoVarBndr ) import GHC.Core.TyCon ( tyConArity )-import TysWiredIn-import PrelNames+import GHC.Builtin.Types+import GHC.Builtin.Names import GHC.Types.Basic-import GHC.Types.Module ( Module )-import ErrUtils+import GHC.Unit.Module ( Module )+import GHC.Utils.Error import GHC.Driver.Session-import Outputable-import Pair-import Util-import Maybes       ( orElse )-import FastString+import GHC.Utils.Outputable+import GHC.Data.Pair+import GHC.Utils.Misc+import GHC.Data.Maybe       ( orElse )+import GHC.Data.FastString import Data.List import qualified Data.ByteString as BS @@ -469,7 +469,7 @@     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 GHC.Core.Op.Simplify.Utils+       | not active            = False --     in GHC.Core.Opt.Simplify.Utils        | 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@@ -489,7 +489,7 @@ {- Note [Exported Ids and trivial RHSs] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We obviously do not want to unconditionally inline an Id that is exported.-In GHC.Core.Op.Simplify.Utils, Note [Top level and postInlineUnconditionally], we+In GHC.Core.Opt.Simplify.Utils, 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 @@ -889,6 +889,10 @@ Notice that both (2) and (3) require exprIsConApp_maybe to gather and return a bunch of floats, both let and case bindings. +Note that this strategy introduces some subtle scenarios where a data-con+wrapper can be replaced by a data-con worker earlier than we’d like, see+Note [exprIsConApp_maybe for data-con wrappers: tricky corner].+ Note [beta-reduction in exprIsConApp_maybe] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The unfolding a definition (_e.g._ a let-bound variable or a datacon wrapper) is@@ -949,6 +953,60 @@ will happen the next time either.  See test T16254, which checks the behavior of newtypes.++Note [exprIsConApp_maybe for data-con wrappers: tricky corner]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Generally speaking++  * exprIsConApp_maybe honours the inline phase; that is, it does not look+    inside the unfolding for an Id unless its unfolding is active in this phase.+    That phase-sensitivity is expressed in the InScopeEnv (specifically, the+    IdUnfoldingFun component of the InScopeEnv) passed to exprIsConApp_maybe.++  * Data-constructor wrappers are active only in phase 0 (the last phase);+    see Note [Activation for data constructor wrappers] in GHC.Types.Id.Make.++On the face of it that means that exprIsConApp_maybe won't look inside data+constructor wrappers until phase 0. But that seems pretty Bad. So we cheat.+For data con wrappers we unconditionally look inside its unfolding, regardless+of phase, so that we get case-of-known-constructor to fire in every phase.++Perhaps unsurprisingly, this cheating can backfire. An example:++    data T = C !A B+    foo p q = let x = C e1 e2 in seq x $ f x+    {-# RULE "wurble" f (C a b) = b #-}++In Core, the RHS of foo is++    let x = $WC e1 e2 in case x of y { C _ _ -> f x }++and after doing a binder swap and inlining x, we have:++    case $WC e1 e2 of y { C _ _ -> f y }++Case-of-known-constructor fires, but now we have to reconstruct a binding for+`y` (which was dead before the binder swap) on the RHS of the case alternative.+Naturally, we’ll use the worker:++    case e1 of a { DEFAULT -> let y = C a e2 in f y }++and after inlining `y`, we have:++    case e1 of a { DEFAULT -> f (C a e2) }++Now we might hope the "wurble" rule would fire, but alas, it will not: we have+replaced $WC with C, but the (desugared) rule matches on $WC! We weren’t+supposed to inline $WC yet for precisely that reason (see Note [Activation for+data constructor wrappers]), but our cheating in exprIsConApp_maybe came back to+bite us.++This is rather unfortunate, especially since this can happen inside stable+unfoldings as well as ordinary code (which really happened, see !3041). But+there is no obvious solution except to delay case-of-known-constructor on+data-con wrappers, and that cure would be worse than the disease.++This Note exists solely to document the problem. -}  data ConCont = CC [CoreExpr] Coercion@@ -1033,7 +1091,8 @@          -- 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.+        -- case-of-known-constructor optimisation eagerly (see Note+        -- [exprIsConApp_maybe on data constructors with wrappers]).         | isDataConWrapId fun         , let rhs = uf_tmpl (realIdUnfolding fun)         = go (Left in_scope) floats rhs cont@@ -1247,7 +1306,7 @@ -- 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 GHC.Core.Op.Simplify+-- C.f. simplCast in GHC.Core.Opt.Simplify -- '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
compiler/GHC/Core/Stats.hs view
@@ -11,11 +11,11 @@         CoreStats(..), coreBindsStats, exprStats,     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Basic import GHC.Core-import Outputable+import GHC.Utils.Outputable import GHC.Core.Coercion import GHC.Types.Var import GHC.Core.Type(Type, typeSize)
compiler/GHC/Core/Subst.hs view
@@ -17,7 +17,7 @@         deShadowBinds, substSpec, substRulesForImportedIds,         substTy, substCo, substExpr, substExprSC, substBind, substBindSC,         substUnfolding, substUnfoldingSC,-        lookupIdSubst, lookupTCvSubst, substIdOcc,+        lookupIdSubst, lookupTCvSubst, substIdType, substIdOcc,         substTickish, substDVarSet, substIdInfo,          -- ** Operations on substitutions@@ -37,7 +37,7 @@ #include "HsVersions.h"  -import GhcPrelude+import GHC.Prelude  import GHC.Core import GHC.Core.FVs@@ -52,7 +52,7 @@    , isInScope, substTyVarBndr, cloneTyVarBndr ) import GHC.Core.Coercion hiding ( substCo, substCoVarBndr ) -import PrelNames+import GHC.Builtin.Names import GHC.Types.Var.Set import GHC.Types.Var.Env import GHC.Types.Id@@ -60,9 +60,9 @@ import GHC.Types.Var import GHC.Types.Id.Info import GHC.Types.Unique.Supply-import Maybes-import Util-import Outputable+import GHC.Data.Maybe+import GHC.Utils.Misc+import GHC.Utils.Outputable import Data.List  @@ -618,7 +618,7 @@   where     old_rules     = ruleInfo info     old_unf       = unfoldingInfo info-    nothing_to_do = isEmptyRuleInfo old_rules && not (isFragileUnfolding old_unf)+    nothing_to_do = isEmptyRuleInfo old_rules && not (hasCoreUnfolding old_unf)  ------------------ -- | Substitutes for the 'Id's within an unfolding@@ -756,4 +756,3 @@ 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/TyCo/FVs.hs view
@@ -43,7 +43,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.Type (coreView, partitionInvisibleTypes) @@ -51,13 +51,13 @@ import GHC.Core.TyCo.Rep import GHC.Core.TyCon import GHC.Types.Var-import FV+import GHC.Utils.FV  import GHC.Types.Unique.FM import GHC.Types.Var.Set import GHC.Types.Var.Env-import Util-import Panic+import GHC.Utils.Misc+import GHC.Utils.Panic  {- %************************************************************************@@ -523,14 +523,14 @@  -- | `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.+-- Note [Deterministic FV] in GHC.Utils.FV. tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet -- See Note [Free variables of types] tyCoVarsOfTypeDSet ty = fvDVarSet $ tyCoFVsOfType ty  -- | `tyCoFVsOfType` that returns free variables of a type in deterministic -- order. For explanation of why using `VarSet` is not deterministic see--- Note [Deterministic FV] in FV.+-- Note [Deterministic FV] in GHC.Utils.FV. tyCoVarsOfTypeList :: Type -> [TyCoVar] -- See Note [Free variables of types] tyCoVarsOfTypeList ty = fvVarList $ tyCoFVsOfType ty@@ -554,10 +554,10 @@ -- make the function quadratic. -- It's exported, so that it can be composed with -- other functions that compute free variables.--- See Note [FV naming conventions] in FV.+-- See Note [FV naming conventions] in GHC.Utils.FV. -- -- Eta-expanded because that makes it run faster (apparently)--- See Note [FV eta expansion] in FV for explanation.+-- See Note [FV eta expansion] in GHC.Utils.FV for explanation. tyCoFVsOfType :: Type -> FV -- See Note [Free variables of types] tyCoFVsOfType (TyVarTy v)        f bound_vars (acc_list, acc_set)@@ -775,7 +775,7 @@ -- See @Note [When does a tycon application need an explicit kind signature?]@. injectiveVarsOfType :: Bool   -- ^ Should we look under injective type families?                               -- See Note [Coverage condition for injective type families]-                              -- in FamInst.+                              -- in GHC.Tc.Instance.Family.                     -> Type -> FV injectiveVarsOfType look_under_tfs = go   where@@ -810,7 +810,7 @@ -- See @Note [When does a tycon application need an explicit kind signature?]@. injectiveVarsOfTypes :: Bool -- ^ look under injective type families?                              -- See Note [Coverage condition for injective type families]-                             -- in FamInst.+                             -- in GHC.Tc.Instance.Family.                      -> [Type] -> FV injectiveVarsOfTypes look_under_tfs = mapUnionFV (injectiveVarsOfType look_under_tfs) @@ -933,7 +933,7 @@ -- -- It is also meant to be stable: that is, variables should not -- be reordered unnecessarily. This is specified in Note [ScopedSort]--- See also Note [Ordering of implicit variables] in GHC.Rename.Types+-- See also Note [Ordering of implicit variables] in GHC.Rename.HsType  scopedSort :: [TyCoVar] -> [TyCoVar] scopedSort = go [] []
compiler/GHC/Core/TyCo/Ppr.hs view
@@ -25,7 +25,7 @@         pprTyThingCategory, pprShortTyThing,   ) where -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.CoreToIface    ( toIfaceTypeX, toIfaceTyLit, toIfaceForAllBndr@@ -50,7 +50,7 @@ import GHC.Types.Var.Set import GHC.Types.Var.Env -import Outputable+import GHC.Utils.Outputable import GHC.Types.Basic ( PprPrec(..), topPrec, sigPrec, opPrec                        , funPrec, appPrec, maybeParen ) @@ -314,7 +314,7 @@ ------------------ -- | Display all kind information (with @-fprint-explicit-kinds@) when the -- provided 'Bool' argument is 'True'.--- See @Note [Kind arguments in error messages]@ in TcErrors.+-- See @Note [Kind arguments in error messages]@ in GHC.Tc.Errors. pprWithExplicitKindsWhen :: Bool -> SDoc -> SDoc pprWithExplicitKindsWhen b   = updSDocContext $ \ctx ->
compiler/GHC/Core/TyCo/Ppr.hs-boot view
@@ -1,7 +1,7 @@ module GHC.Core.TyCo.Ppr where  import {-# SOURCE #-} GHC.Core.TyCo.Rep (Type, Kind, Coercion, TyLit)-import Outputable+import GHC.Utils.Outputable  pprType :: Type -> SDoc pprKind :: Kind -> SDoc
compiler/GHC/Core/TyCo/Rep.hs view
@@ -7,14 +7,14 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   GHC.Core.Class   GHC.Core.Coercion.Axiom-  GHC.Core.TyCon      imports GHC.Core.{Class, Coercion.Axiom}-  GHC.Core.TyCo.Rep   imports GHC.Core.{Class, Coercion.Axiom, TyCon}-  GHC.Core.TyCo.Ppr   imports GHC.Core.TyCo.Rep-  GHC.Core.TyCo.FVs   imports GHC.Core.TyCo.Rep-  GHC.Core.TyCo.Subst imports GHC.Core.TyCo.{Rep, FVs, Ppr}-  GHC.Core.TyCo.Tidy  imports GHC.Core.TyCo.{Rep, FVs}-  TysPrim             imports GHC.Core.TyCo.Rep ( including mkTyConTy )-  GHC.Core.Coercion   imports GHC.Core.Type+  GHC.Core.TyCon           imports GHC.Core.{Class, Coercion.Axiom}+  GHC.Core.TyCo.Rep        imports GHC.Core.{Class, Coercion.Axiom, TyCon}+  GHC.Core.TyCo.Ppr        imports GHC.Core.TyCo.Rep+  GHC.Core.TyCo.FVs        imports GHC.Core.TyCo.Rep+  GHC.Core.TyCo.Subst      imports GHC.Core.TyCo.{Rep, FVs, Ppr}+  GHC.Core.TyCo.Tidy       imports GHC.Core.TyCo.{Rep, FVs}+  GHC.Builtin.Types.Prim   imports GHC.Core.TyCo.Rep ( including mkTyConTy )+  GHC.Core.Coercion        imports GHC.Core.Type -}  -- We expose the relevant stuff from this module via the Type module@@ -70,7 +70,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.TyCo.Ppr ( pprType, pprCo, pprTyLit ) @@ -88,9 +88,9 @@  -- others import GHC.Types.Basic ( LeftOrRight(..), pickLR )-import Outputable-import FastString-import Util+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Utils.Misc  -- libraries import qualified Data.Data as Data hiding ( TyCon )@@ -105,7 +105,7 @@  Despite the fact that DataCon has to be imported via a hi-boot route, this module seems the right place for TyThing, because it's needed for-funTyCon and all the types in TysPrim.+funTyCon and all the types in GHC.Builtin.Types.Prim.  It is also SOURCE-imported into Name.hs @@ -121,7 +121,7 @@  -- | A global typecheckable-thing, essentially anything that has a name. -- Not to be confused with a 'TcTyThing', which is also a typecheckable--- thing but in the *local* context.  See 'TcEnv' for how to retrieve+-- thing but in the *local* context.  See 'GHC.Tc.Utils.Env' for how to retrieve -- a 'TyThing' given a 'Name'. data TyThing   = AnId     Id@@ -356,7 +356,7 @@  How does this work? -* In TcValidity.checkConstraintsOK we reject kinds that+* In GHC.Tc.Validity.checkConstraintsOK we reject kinds that   have constraints other than (a~b) and (a~~b).  * In Inst.tcInstInvisibleTyBinder we instantiate a call@@ -377,10 +377,10 @@  * We support both homogeneous (~) and heterogeneous (~~)   equality.  (See Note [The equality types story]-  in TysPrim for a primer on these equality types.)+  in GHC.Builtin.Types.Prim for a primer on these equality types.)  * How do we prevent a MkT having an illegal constraint like-  Eq a?  We check for this at use-sites; see TcHsType.tcTyVar,+  Eq a?  We check for this at use-sites; see GHC.Tc.Gen.HsType.tcTyVar,   specifically dc_theta_illegal_constraint.  * Notice that nothing special happens if@@ -663,7 +663,7 @@  -- | A type labeled 'KnotTied' might have knot-tied tycons in it. See -- Note [Type checking recursive type and class declarations] in--- TcTyClsDecls+-- GHC.Tc.TyCl type KnotTied ty = ty  {- **********************************************************************@@ -856,7 +856,7 @@ and its kind prints as    Foo :: forall a -> forall b. (a -> b -> Type) -> Type -See also Note [Required, Specified, and Inferred for types] in TcTyClsDecls+See also Note [Required, Specified, and Inferred for types] in GHC.Tc.TyCl  ---- Printing ----- @@ -892,7 +892,7 @@ anyway.  (Most are Anons.)  However the type of a term can (just about) have a required quantifier;-see Note [Required quantifiers in the type of a term] in TcExpr.+see Note [Required quantifiers in the type of a term] in GHC.Tc.Gen.Expr. -}  @@ -948,7 +948,7 @@ %*                                                                      * %************************************************************************ -These functions are here so that they can be used by TysPrim,+These functions are here so that they can be used by GHC.Builtin.Types.Prim, which in turn is imported by Type -} @@ -1594,7 +1594,7 @@     which actually binds d7 to the (Num a) evidence  For equality constraints we use a different strategy.  See Note [The-equality types story] in TysPrim for background on equality constraints.+equality types story] in GHC.Builtin.Types.Prim for background on equality constraints.   - For /boxed/ equality constraints, (t1 ~N t2) and (t1 ~R t2), it's just     like type classes above. (Indeed, boxed equality constraints *are* classes.)   - But for /unboxed/ equality constraints (t1 ~R# t2) and (t1 ~N# t2)@@ -1603,7 +1603,7 @@ For unboxed equalities:   - Generate a CoercionHole, a mutable variable just like a unification     variable-  - Wrap the CoercionHole in a Wanted constraint; see TcRnTypes.TcEvDest+  - Wrap the CoercionHole in a Wanted constraint; see GHC.Tc.Utils.TcEvDest   - Use the CoercionHole in a Coercion, via HoleCo   - Solve the constraint later   - When solved, fill in the CoercionHole by side effect, instead of@@ -1650,7 +1650,7 @@ Why does a CoercionHole contain a CoVar, as well as reference to fill in?  Because we want to treat that CoVar as a free variable of the coercion.  See #14584, and Note [What prevents a-constraint from floating] in TcSimplify, item (4):+constraint from floating] in GHC.Tc.Solver, item (4):          forall k. [W] co1 :: t1 ~# t2 |> co2                   [W] co2 :: k ~# *
compiler/GHC/Core/TyCo/Subst.hs view
@@ -53,7 +53,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.Type    ( mkCastTy, mkAppTy, isCoercionTy )@@ -74,13 +74,13 @@ import GHC.Types.Var.Set import GHC.Types.Var.Env -import Pair-import Util+import GHC.Data.Pair+import GHC.Utils.Misc import GHC.Types.Unique.Supply import GHC.Types.Unique import GHC.Types.Unique.FM import GHC.Types.Unique.Set-import Outputable+import GHC.Utils.Outputable  import Data.List (mapAccumL)
compiler/GHC/Core/TyCo/Tidy.hs view
@@ -18,7 +18,7 @@         tidyTyCoVarBinder, tidyTyCoVarBinders   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Core.TyCo.Rep import GHC.Core.TyCo.FVs (tyCoVarsOfTypesWellScoped, tyCoVarsOfTypeList)@@ -26,7 +26,7 @@ import GHC.Types.Name hiding (varName) import GHC.Types.Var import GHC.Types.Var.Env-import Util (seqList)+import GHC.Utils.Misc (seqList)  import Data.List (mapAccumL)
compiler/GHC/Core/TyCon.hs view
@@ -45,7 +45,7 @@         noTcTyConScopedTyVars,          -- ** Predicates on TyCons-        isAlgTyCon, isVanillaAlgTyCon,+        isAlgTyCon, isVanillaAlgTyCon, isConstraintKindCon,         isClassTyCon, isFamInstTyCon,         isFunTyCon,         isPrimTyCon,@@ -134,14 +134,14 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude import GHC.Platform  import {-# SOURCE #-} GHC.Core.TyCo.Rep    ( Kind, Type, PredType, mkForAllTy, mkFunTy ) import {-# SOURCE #-} GHC.Core.TyCo.Ppr    ( pprType )-import {-# SOURCE #-} TysWiredIn+import {-# SOURCE #-} GHC.Builtin.Types    ( runtimeRepTyCon, constraintKind    , vecCountTyCon, vecElemTyCon, liftedTypeKind ) import {-# SOURCE #-} GHC.Core.DataCon@@ -149,7 +149,7 @@    , dataConTyCon, dataConFullSig    , isUnboxedSumCon ) -import Binary+import GHC.Utils.Binary import GHC.Types.Var import GHC.Types.Var.Set import GHC.Core.Class@@ -158,16 +158,16 @@ import GHC.Types.Name import GHC.Types.Name.Env import GHC.Core.Coercion.Axiom-import PrelNames-import Maybes-import Outputable-import FastStringEnv+import GHC.Builtin.Names+import GHC.Data.Maybe+import GHC.Utils.Outputable+import GHC.Data.FastString.Env import GHC.Types.FieldLabel-import Constants-import Util+import GHC.Settings.Constants+import GHC.Utils.Misc import GHC.Types.Unique( tyConRepNameUnique, dataConTyRepNameUnique ) import GHC.Types.Unique.Set-import GHC.Types.Module+import GHC.Unit.Module  import qualified Data.Data as Data @@ -240,7 +240,7 @@         DataFamInstTyCon T [Int] ax_ti  * The axiom ax_ti may be eta-reduced; see-  Note [Eta reduction for data families] in GHC.Core.FamInstEnv+  Note [Eta reduction for data families] in GHC.Core.Coercion.Axiom  * Data family instances may have a different arity than the data family.   See Note [Arity of data families] in GHC.Core.FamInstEnv@@ -311,7 +311,7 @@   data type with some axioms that connect it to other data types.  * The tyConTyVars of the representation tycon are the tyvars that the-  user wrote in the patterns. This is important in TcDeriv, where we+  user wrote in the patterns. This is important in GHC.Tc.Deriv, where we   bring these tyvars into scope before type-checking the deriving   clause. This fact is arranged for in TcInstDecls.tcDataFamInstDecl. @@ -355,7 +355,7 @@   data T a b c where     MkT :: b -> T Int b c -Data and class tycons have their roles inferred (see inferRoles in TcTyDecls),+Data and class tycons have their roles inferred (see inferRoles in GHC.Tc.TyCl.Utils), as do vanilla synonym tycons. Family tycons have all parameters at role N, though it is conceivable that we could relax this restriction. (->)'s and tuples' parameters are at role R. Each primitive tycon declares its roles;@@ -405,9 +405,9 @@  See also:  * [Injectivity annotation] in GHC.Hs.Decls- * [Renaming injectivity annotation] in GHC.Rename.Source+ * [Renaming injectivity annotation] in GHC.Rename.Module  * [Verifying injectivity annotation] in GHC.Core.FamInstEnv- * [Type inference for type families with injectivity] in TcInteract+ * [Type inference for type families with injectivity] in GHC.Tc.Solver.Interact  ************************************************************************ *                                                                      *@@ -830,7 +830,7 @@         tyConKind    :: Kind,             -- ^ Kind of this TyCon         tyConArity   :: Arity,            -- ^ Arity             -- tyConTyVars connect an associated family TyCon-            -- with its parent class; see TcValidity.checkConsistentFamInst+            -- with its parent class; see GHC.Tc.Validity.checkConsistentFamInst          famTcResVar  :: Maybe Name,   -- ^ Name of result type variable, used                                       -- for pretty-printing with --show-iface@@ -897,7 +897,7 @@     }    -- | These exist only during type-checking. See Note [How TcTyCons work]-  -- in TcTyClsDecls+  -- in GHC.Tc.TyCl   | TcTyCon {         tyConUnique :: Unique,         tyConName   :: Name,@@ -938,7 +938,7 @@    * required_tvs the same as tyConTyVars    * tyConArity = length required_tvs -See also Note [How TcTyCons work] in TcTyClsDecls+See also Note [How TcTyCons work] in GHC.Tc.TyCl -}  -- | Represents right-hand-sides of 'TyCon's for algebraic types@@ -1100,8 +1100,9 @@                -- and R:T is the representation TyCon (ie this one)                -- and a,b,c are the tyConTyVars of this TyCon                ---               -- BUT may be eta-reduced; see FamInstEnv-               --     Note [Eta reduction for data families]+               -- BUT may be eta-reduced; see+               --     Note [Eta reduction for data families] in+               --     GHC.Core.Coercion.Axiom            -- Cached fields of the CoAxiom, but adjusted to           -- use the tyConTyVars of this TyCon@@ -1296,7 +1297,7 @@         kind:    T ~ []  and    arity:   0 -This eta-reduction is implemented in BuildTyCl.mkNewTyConRhs.+This eta-reduction is implemented in GHC.Tc.TyCl.Build.mkNewTyConRhs.   ************************************************************************@@ -1330,7 +1331,7 @@  -- | Make a 'Name' for the 'Typeable' representation of the given wired-in type mkPrelTyConRepName :: Name -> TyConRepName--- See Note [Grand plan for Typeable] in 'TcTypeable' in TcTypeable.+-- See Note [Grand plan for Typeable] in 'GHC.Tc.Instance.Typeable'. mkPrelTyConRepName tc_name  -- Prelude tc_name is always External,                             -- so nameModule will work   = mkExternalName rep_uniq rep_mod rep_occ (nameSrcSpan tc_name)@@ -1345,7 +1346,7 @@ -- | The name (and defining module) for the Typeable representation (TyCon) of a -- type constructor. ----- See Note [Grand plan for Typeable] in 'TcTypeable' in TcTypeable.+-- See Note [Grand plan for Typeable] in 'GHC.Tc.Instance.Typeable'. tyConRepModOcc :: Module -> OccName -> (Module, OccName) tyConRepModOcc tc_module tc_occ = (rep_module, mkTyConRepOcc tc_occ)   where@@ -1701,12 +1702,12 @@ -- mutually-recursive group of tycons; it is then zonked to a proper -- TyCon in zonkTcTyCon. -- See also Note [Kind checking recursive type and class declarations]--- in TcTyClsDecls.+-- in GHC.Tc.TyCl. mkTcTyCon :: Name           -> [TyConBinder]           -> Kind                -- ^ /result/ kind only           -> [(Name,TcTyVar)]    -- ^ Scoped type variables;-                                 -- see Note [How TcTyCons work] in TcTyClsDecls+                                 -- see Note [How TcTyCons work] in GHC.Tc.TyCl           -> Bool                -- ^ Is this TcTyCon generalised already?           -> TyConFlavour        -- ^ What sort of 'TyCon' this represents           -> TyCon@@ -1867,6 +1868,15 @@ isVanillaAlgTyCon (AlgTyCon { algTcParent = VanillaAlgTyCon _ }) = True isVanillaAlgTyCon _                                              = False +-- | Returns @True@ for the 'TyCon' of the 'Constraint' kind.+isConstraintKindCon :: TyCon -> Bool+-- NB: We intentionally match on AlgTyCon, because 'constraintKindTyCon' is+-- always an AlgTyCon (see 'pcTyCon' in TysWiredIn) and the record selector+-- for 'tyConUnique' would generate unreachable code for every other data+-- constructor of TyCon (see #18026).+isConstraintKindCon AlgTyCon { tyConUnique = u } = u == constraintKindTyConKey+isConstraintKindCon _                            = False+ isDataTyCon :: TyCon -> Bool -- ^ Returns @True@ for data types that are /definitely/ represented by -- heap-allocated constructors.  These are scrutinised by Core-level@@ -1893,7 +1903,7 @@ -- (where X is the role passed in): --   If (T a1 b1 c1) ~X (T a2 b2 c2), then (a1 ~X1 a2), (b1 ~X2 b2), and (c1 ~X3 c2) -- (where X1, X2, and X3, are the roles given by tyConRolesX tc X)--- See also Note [Decomposing equality] in TcCanonical+-- See also Note [Decomposing equality] in GHC.Tc.Solver.Canonical isInjectiveTyCon :: TyCon -> Role -> Bool isInjectiveTyCon _                             Phantom          = False isInjectiveTyCon (FunTyCon {})                 _                = True@@ -1909,12 +1919,12 @@ isInjectiveTyCon (PromotedDataCon {})          _                = True isInjectiveTyCon (TcTyCon {})                  _                = True   -- Reply True for TcTyCon to minimise knock on type errors-  -- See Note [How TcTyCons work] item (1) in TcTyClsDecls+  -- See Note [How TcTyCons work] item (1) in GHC.Tc.TyCl  -- | 'isGenerativeTyCon' is true of 'TyCon's for which this property holds -- (where X is the role passed in): --   If (T tys ~X t), then (t's head ~X T).--- See also Note [Decomposing equality] in TcCanonical+-- See also Note [Decomposing equality] in GHC.Tc.Solver.Canonical isGenerativeTyCon :: TyCon -> Role -> Bool isGenerativeTyCon (FamilyTyCon { famTcFlav = DataFamilyTyCon _ }) Nominal = True isGenerativeTyCon (FamilyTyCon {}) _ = False@@ -2248,7 +2258,7 @@ -- Update the Kind of a TcTyCon -- The new kind is always a zonked version of its previous -- kind, so we don't need to update any other fields.--- See Note [The Purely Kinded Invariant] in TcHsType+-- See Note [The Purely Kinded Invariant] in GHC.Tc.Gen.HsType setTcTyConKind tc@(TcTyCon {}) kind = tc { tyConKind = kind } setTcTyConKind tc              _    = pprPanic "setTcTyConKind" (ppr tc) @@ -2303,7 +2313,7 @@ --  with user defined constructors rather than one from a class or other --  construction. --- NB: This is only used in TcRnExports.checkPatSynParent to determine if an+-- NB: This is only used in GHC.Tc.Gen.Export.checkPatSynParent to determine if an -- exported tycon can have a pattern synonym bundled with it, e.g., -- module Foo (TyCon(.., PatSyn)) where isTyConWithSrcDataCons :: TyCon -> Bool
compiler/GHC/Core/TyCon.hs-boot view
@@ -1,6 +1,6 @@ module GHC.Core.TyCon where -import GhcPrelude+import GHC.Prelude  data TyCon
compiler/GHC/Core/Type.hs view
@@ -221,7 +221,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Basic @@ -240,13 +240,14 @@ import GHC.Types.Unique.Set  import GHC.Core.TyCon-import TysPrim-import {-# SOURCE #-} TysWiredIn ( listTyCon, typeNatKind+import GHC.Builtin.Types.Prim+import {-# SOURCE #-} GHC.Builtin.Types+                                 ( listTyCon, typeNatKind                                  , typeSymbolKind, liftedTypeKind                                  , liftedTypeKindTyCon                                  , constraintKind ) import GHC.Types.Name( Name )-import PrelNames+import GHC.Builtin.Names import GHC.Core.Coercion.Axiom import {-# SOURCE #-} GHC.Core.Coercion    ( mkNomReflCo, mkGReflCo, mkReflCo@@ -259,15 +260,15 @@    , isReflexiveCo, seqCo )  -- others-import Util-import FV-import Outputable-import FastString-import Pair-import ListSetOps+import GHC.Utils.Misc+import GHC.Utils.FV+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Data.Pair+import GHC.Data.List.SetOps import GHC.Types.Unique ( nonDetCmpUnique ) -import Maybes           ( orElse )+import GHC.Data.Maybe   ( orElse ) import Data.Maybe       ( isJust ) import Control.Monad    ( guard ) @@ -615,7 +616,7 @@           -- a) To zonk TcTyCons           -- b) To turn TcTyCons into TyCons.           --    See Note [Type checking recursive type and class declarations]-          --    in TcTyClsDecls+          --    in GHC.Tc.TyCl       }  {-# INLINE mapTyCo #-}  -- See Note [Specialising mappers]@@ -809,7 +810,7 @@         -- Here Id is partially applied in the type sig for Foo,         -- but once the type synonyms are expanded all is well         ---        -- Moreover in TcHsTypes.tcInferApps we build up a type+        -- Moreover in GHC.Tc.Types.tcInferApps we build up a type         --   (T t1 t2 t3) one argument at a type, thus forming         --   (T t1), (T t1 t2), etc @@ -1325,7 +1326,7 @@ -- have enough info to extract the runtime-rep arguments that -- the funTyCon requires.  This will usually be true; -- but may be temporarily false during canonicalization:---     see Note [FunTy and decomposing tycon applications] in TcCanonical+--     see Note [FunTy and decomposing tycon applications] in GHC.Tc.Solver.Canonical -- repSplitTyConApp_maybe (TyConApp tc tys) = Just (tc, tys) repSplitTyConApp_maybe (FunTy _ arg res)@@ -1456,7 +1457,7 @@ not                                ([a], a -> a)  The reason is that we then get better (shorter) type signatures in-interfaces.  Notably this plays a role in tcTySigs in TcBinds.hs.+interfaces.  Notably this plays a role in tcTySigs in GHC.Tc.Gen.Bind.   ---------------------------------------------------------------------@@ -2447,7 +2448,7 @@    forall r. (ty :: K r) because the kind of the forall would escape the binding of 'r'.  But in this case it's fine because (K r) exapands-to Type, so we expliclity /permit/ the type+to Type, so we explicitly /permit/ the type    forall r. T r  To accommodate such a type, in typeKind (forall a.ty) we use@@ -2455,8 +2456,13 @@ to eliminate 'a'.  See kinding rule (FORALL) in Note [Kinding rules for types] -And in TcValidity.checkEscapingKind, we use also use-occCheckExpand, for the same reason.+See also+ * GHC.Core.Type.occCheckExpand+ * GHC.Core.Utils.coreAltsType+ * GHC.Tc.Validity.checkEscapingKind+all of which grapple with with the same problem.++See #14939. -}  -----------------------------@@ -2924,9 +2930,6 @@ during type inference. -} -isConstraintKindCon :: TyCon -> Bool-isConstraintKindCon tc = tyConUnique tc == constraintKindTyConKey- -- | Tests whether the given kind (which should look like @TYPE x@) -- is something other than a constructor tree (that is, constructors at every node). -- E.g.  True of   TYPE k, TYPE (F Int)@@ -3024,7 +3027,7 @@ There are a couple of places in GHC where we convert Core Types into forms that more closely resemble user-written syntax. These include: -1. Template Haskell Type reification (see, for instance, TcSplice.reify_tc_app)+1. Template Haskell Type reification (see, for instance, GHC.Tc.Gen.Splice.reify_tc_app) 2. Converting Types to LHsTypes (in GHC.Hs.Utils.typeToLHsType, or in Haddock)  This conversion presents a challenge: how do we ensure that the resulting type@@ -3064,7 +3067,7 @@ require a kind signature? It might require it when we need to fill in any of T's omitted arguments. By "omitted argument", we mean one that is dropped when reifying ty_1 ... ty_n. Sometimes, the omitted arguments are inferred and-specified arguments (e.g., TH reification in TcSplice), and sometimes the+specified arguments (e.g., TH reification in GHC.Tc.Gen.Splice), and sometimes the omitted arguments are only the inferred ones (e.g., in GHC.Hs.Utils.typeToLHsType, which reifies specified arguments through visible kind application). Regardless, the key idea is that _some_ arguments are going to be omitted after
compiler/GHC/Core/Type.hs-boot view
@@ -2,10 +2,10 @@  module GHC.Core.Type where -import GhcPrelude+import GHC.Prelude import GHC.Core.TyCon import {-# SOURCE #-} GHC.Core.TyCo.Rep( Type, Coercion )-import Util+import GHC.Utils.Misc  isPredTy     :: HasDebugCallStack => Type -> Bool isCoercionTy :: Type -> Bool
compiler/GHC/Core/Unfold.hs view
@@ -22,9 +22,9 @@ module GHC.Core.Unfold (         Unfolding, UnfoldingGuidance,   -- Abstract types -        noUnfolding, mkImplicitUnfolding,+        noUnfolding,         mkUnfolding, mkCoreUnfolding,-        mkTopUnfolding, mkSimpleUnfolding, mkWorkerUnfolding,+        mkFinalUnfolding, mkSimpleUnfolding, mkWorkerUnfolding,         mkInlineUnfolding, mkInlineUnfoldingWithArity,         mkInlinableUnfolding, mkWwInlineRule,         mkCompulsoryUnfolding, mkDFunUnfolding,@@ -44,30 +44,30 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Driver.Session import GHC.Core-import GHC.Core.Op.OccurAnal ( occurAnalyseExpr_NoBinderSwap )+import GHC.Core.Opt.OccurAnal ( occurAnalyseExpr ) import GHC.Core.SimpleOpt import GHC.Core.Arity   ( manifestArity ) import GHC.Core.Utils import GHC.Types.Id-import GHC.Types.Demand ( isBottomingSig )+import GHC.Types.Demand ( StrictSig, isBottomingSig ) import GHC.Core.DataCon import GHC.Types.Literal-import PrimOp+import GHC.Builtin.PrimOps import GHC.Types.Id.Info import GHC.Types.Basic  ( Arity, InlineSpec(..), inlinePragmaSpec ) import GHC.Core.Type-import PrelNames-import TysPrim          ( realWorldStatePrimTy )-import Bag-import Util-import Outputable+import GHC.Builtin.Names+import GHC.Builtin.Types.Prim ( realWorldStatePrimTy )+import GHC.Data.Bag+import GHC.Utils.Misc+import GHC.Utils.Outputable import GHC.Types.ForeignCall import GHC.Types.Name-import ErrUtils+import GHC.Utils.Error  import qualified Data.ByteString as BS import Data.List@@ -80,15 +80,23 @@ ************************************************************************ -} -mkTopUnfolding :: DynFlags -> Bool -> CoreExpr -> Unfolding-mkTopUnfolding dflags is_bottoming rhs-  = mkUnfolding dflags InlineRhs True is_bottoming rhs+mkFinalUnfolding :: DynFlags -> UnfoldingSource -> StrictSig -> CoreExpr -> Unfolding+-- "Final" in the sense that this is a GlobalId that will not be further+-- simplified; so the unfolding should be occurrence-analysed+mkFinalUnfolding dflags src strict_sig expr+  = mkUnfolding dflags src+                True {- Top level -}+                (isBottomingSig strict_sig)+                expr -mkImplicitUnfolding :: DynFlags -> CoreExpr -> Unfolding--- For implicit Ids, do a tiny bit of optimising first-mkImplicitUnfolding dflags expr-  = mkTopUnfolding dflags False (simpleOptExpr dflags expr)+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 }) + -- Note [Top-level flag on inline rules] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- Slight hack: note that mk_inline_rules conservatively sets the@@ -103,7 +111,7 @@ mkDFunUnfolding bndrs con ops   = DFunUnfolding { df_bndrs = bndrs                   , df_con = con-                  , df_args = map occurAnalyseExpr_NoBinderSwap ops }+                  , df_args = map occurAnalyseExpr ops }                   -- See Note [Occurrence analysis of unfoldings]  mkWwInlineRule :: DynFlags -> CoreExpr -> Arity -> Unfolding@@ -113,15 +121,8 @@                    (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 GHC.Core.Op.WorkWrap+-- See Note [Worker-wrapper for INLINABLE functions] in GHC.Core.Opt.WorkWrap mkWorkerUnfolding dflags work_fn                   (CoreUnfolding { uf_src = src, uf_tmpl = tmpl                                  , uf_is_top = top_lvl })@@ -172,15 +173,16 @@   where     expr' = simpleOptExpr dflags expr -specUnfolding :: DynFlags -> [Var] -> (CoreExpr -> CoreExpr) -> Arity+specUnfolding :: DynFlags -> Id -> [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+specUnfolding dflags fn 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 )+  = ASSERT2( arity_decrease == count isId old_bndrs - count isId spec_bndrs+           , ppr df $$ ppr spec_bndrs $$ ppr (spec_app (Var fn)) $$ ppr arity_decrease )     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@@ -194,7 +196,7 @@                    -- The beta-redexes created by spec_app will be                    -- simplified away by simplOptExpr -specUnfolding dflags spec_bndrs spec_app arity_decrease+specUnfolding dflags _ spec_bndrs spec_app arity_decrease               (CoreUnfolding { uf_src = src, uf_tmpl = tmpl                              , uf_is_top = top_lvl                              , uf_guidance = old_guidance })@@ -211,7 +213,7 @@     in mkCoreUnfolding src top_lvl new_tmpl guidance -specUnfolding _ _ _ _ _ = noUnfolding+specUnfolding _ _ _ _ _ _ = noUnfolding  {- Note [Specialising unfoldings] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -309,20 +311,6 @@ 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@@ -331,22 +319,29 @@             -> 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,+mkUnfolding dflags src top_lvl is_bottoming expr+  = mkCoreUnfolding src top_lvl expr guidance+  where+    is_top_bottoming = top_lvl && is_bottoming+    guidance         = calcUnfoldingGuidance dflags is_top_bottoming expr+        -- NB: *not* (calcUnfoldingGuidance (occurAnalyseExpr expr))!+        -- See Note [Calculate unfolding guidance on the non-occ-anal'd expression]++mkCoreUnfolding :: UnfoldingSource -> Bool -> CoreExpr+                -> UnfoldingGuidance -> Unfolding+-- Occurrence-analyses the expression before capturing it+mkCoreUnfolding src top_lvl expr guidance+  = CoreUnfolding { uf_tmpl         = occurAnalyseExpr expr,                       -- See Note [Occurrence analysis of unfoldings]                     uf_src          = src,-                    uf_is_top       = is_top_lvl,+                    uf_is_top       = top_lvl,                     uf_is_value     = exprIsHNF        expr,                     uf_is_conlike   = exprIsConLike    expr,-                    uf_expandable   = exprIsExpandable expr,                     uf_is_work_free = exprIsWorkFree   expr,+                    uf_expandable   = exprIsExpandable 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] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -366,39 +361,6 @@ 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@@ -537,7 +499,7 @@ 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 GHC.Core.Op.SetLevels.+and similar friends.  See Note [Bottoming floats] in GHC.Core.Opt.SetLevels. Do not re-inline them!  But we *do* still inline if they are very small (the uncondInline stuff). @@ -590,7 +552,7 @@     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 GHC.Core.Op.Simplify.Utils+    but it doesn't fire for top-level things; see GHC.Core.Opt.Simplify.Utils     Note [Top level and postInlineUnconditionally]  Note [Count coercion arguments in boring contexts]@@ -1040,10 +1002,6 @@      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@@ -1062,6 +1020,22 @@      loop breakers.  +Historical Note: Before April 2020 we had another factor,+ufKeenessFactor, which would scale the discounts before they were subtracted+from the size. This was justified with the following comment:++  -- We multiply 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.++However, this is highly suspect since it means that we subtract a *scaled* size+from an absolute size, resulting in crazy (e.g. negative) scores in some cases+(#15304). We consequently killed off ufKeenessFactor and bumped up the+ufUseThreshold to compensate.++ Note [Function applications] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In a function application (f a b)@@ -1345,8 +1319,7 @@           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+          discount = computeDiscount arg_discounts res_discount arg_infos cont_info    where     mk_doc some_benefit extra_doc yes_or_no@@ -1591,14 +1564,9 @@  -} -computeDiscount :: DynFlags -> [Int] -> Int -> [ArgSummary] -> CallCtxt+computeDiscount :: [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.+computeDiscount arg_discounts res_discount arg_infos cont_info    = 10          -- Discount of 10 because the result replaces the call                 -- so we count 10 for the function itself@@ -1607,8 +1575,7 @@                -- Discount of 10 for each arg supplied,                -- because the result replaces the call -    + round (ufKeenessFactor dflags *-             fromIntegral (total_arg_discount + res_discount'))+    + total_arg_discount + res_discount'   where     actual_arg_discounts = zipWith mk_arg_discount arg_discounts arg_infos     total_arg_discount   = sum actual_arg_discounts
compiler/GHC/Core/Unfold.hs-boot view
@@ -2,7 +2,7 @@         mkUnfolding, mkInlineUnfolding     ) where -import GhcPrelude+import GHC.Prelude import GHC.Core import GHC.Driver.Session
compiler/GHC/Core/Unify.hs view
@@ -26,7 +26,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Var import GHC.Types.Var.Env@@ -38,10 +38,10 @@ import GHC.Core.TyCo.Rep import GHC.Core.TyCo.FVs   ( tyCoVarsOfCoList, tyCoFVsOfTypes ) import GHC.Core.TyCo.Subst ( mkTvSubst )-import FV( FV, fvVarSet, fvVarList )-import Util-import Pair-import Outputable+import GHC.Utils.FV( FV, fvVarSet, fvVarList )+import GHC.Utils.Misc+import GHC.Data.Pair+import GHC.Utils.Outputable import GHC.Types.Unique.FM import GHC.Types.Unique.Set @@ -410,7 +410,7 @@                                 -- for 'tcUnifyTysFG'  -- The two types may have common type variables, and indeed do so in the--- second call to tcUnifyTys in FunDeps.checkClsFD+-- second call to tcUnifyTys in GHC.Tc.Instance.FunDeps.checkClsFD tcUnifyTys bind_fn tys1 tys2   = case tcUnifyTysFG bind_fn tys1 tys2 of       Unifiable result -> Just result@@ -684,7 +684,7 @@ see Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep  Unlike the "impure unifiers" in the typechecker (the eager unifier in-TcUnify, and the constraint solver itself in TcCanonical), the pure+GHC.Tc.Utils.Unify, and the constraint solver itself in GHC.Tc.Solver.Canonical), the pure unifier It does /not/ work up to ~.  The algorithm implemented here is rather delicate, and we depend on it
compiler/GHC/Core/Utils.hs view
@@ -62,11 +62,11 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude import GHC.Platform  import GHC.Core-import PrelNames ( makeStaticName )+import GHC.Builtin.Names ( makeStaticName ) import GHC.Core.Ppr import GHC.Core.FVs( exprFreeVars ) import GHC.Types.Var@@ -76,29 +76,29 @@ import GHC.Types.Name import GHC.Types.Literal import GHC.Core.DataCon-import PrimOp+import GHC.Builtin.PrimOps import GHC.Types.Id import GHC.Types.Id.Info-import PrelNames( absentErrorIdKey )+import GHC.Builtin.Names( absentErrorIdKey ) import GHC.Core.Type as Type import GHC.Core.Predicate import GHC.Core.TyCo.Rep( TyCoBinder(..), TyBinder ) import GHC.Core.Coercion import GHC.Core.TyCon import GHC.Types.Unique-import Outputable-import TysPrim-import FastString-import Maybes-import ListSetOps       ( minusList )-import GHC.Types.Basic     ( Arity, isConLike )-import Util-import Pair+import GHC.Utils.Outputable+import GHC.Builtin.Types.Prim+import GHC.Data.FastString+import GHC.Data.Maybe+import GHC.Data.List.SetOps( minusList )+import GHC.Types.Basic     ( Arity )+import GHC.Utils.Misc+import GHC.Data.Pair import Data.ByteString     ( ByteString ) import Data.Function       ( on ) import Data.List import Data.Ord            ( comparing )-import OrdList+import GHC.Data.OrdList import qualified Data.Set as Set import GHC.Types.Unique.Set @@ -162,7 +162,7 @@    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 GHC.Core.Op.SetLevels+   go (Coercion {})                = False  -- this case can happen in GHC.Core.Opt.SetLevels     check_type = isTypeLevPoly . exprType  -- slow approach @@ -625,7 +625,7 @@ we generate (error "Inaccessible alternative").  Similar things can happen (augmented by GADTs) when the Simplifier-filters down the matching alternatives in GHC.Core.Op.Simplify.rebuildCase.+filters down the matching alternatives in GHC.Core.Opt.Simplify.rebuildCase. -}  ---------------------------------@@ -696,7 +696,7 @@     impossible_alt _  _                         = False  -- | Refine the default alternative to a 'DataAlt', if there is a unique way to do so.--- See Note [Refine Default Alts]+-- See Note [Refine DEFAULT case alternatives] refineDefaultAlt :: [Unique]          -- ^ Uniques for constructing new binders                  -> TyCon             -- ^ Type constructor of scrutinee's type                  -> [Type]            -- ^ Type arguments of scrutinee's type@@ -739,95 +739,62 @@   | 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.+{- Note [Refine DEFAULT case alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+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.+    foo :: () -> ()+    foo x = case x of !_ -> ()+which rewrites to+    foo :: () -> ()+    foo x = case x of () -> () -If we apply refineDefaultAlt first, we get+There are two reasons in general why replacing a DEFAULT alternative+with a specific constructor is desirable. -```-case e of-  C0 -> e1-  C1 -> e1-  C2 -> e0-```+1. We can simplify inner expressions.  For example -and combineIdenticalAlts can turn that into+       data Foo = Foo1 () -```-case e of-  DEFAULT -> e1-  C2 -> e0-```+       test :: Foo -> ()+       test x = case x of+                  DEFAULT -> mid (case x of+                                    Foo1 x1 -> x1) -It isn't obvious that refineDefaultAlt does this but if you look at its one call-site in GHC.Core.Op.Simplify.Utils then the `imposs_deflt_cons` argument is-populated with constructors which are matched elsewhere.+   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. If we don't+   refine DEFAULT to `Foo ip1`, we are left with both case expressions. --}+2. combineIdenticalAlts does a better job. For exapple (Simon Jacobi)+       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.+   But 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 GHC.Core.Opt.Simplify.Utils then the+   `imposs_deflt_cons` argument is populated with constructors which+   are matched elsewhere. -{- Note [Combine identical alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+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:@@ -874,7 +841,7 @@   isDeadBinder (see #7360).    You can see this in the call to combineIdenticalAlts in-  GHC.Core.Op.Simplify.Utils.prepareAlts.  Here the alternatives have type InAlt+  GHC.Core.Opt.Simplify.Utils.prepareAlts.  Here the alternatives have type InAlt   (the "In" meaning input) rather than OutAlt.  * combineIdenticalAlts does not work well for nullary constructors@@ -882,10 +849,10 @@          []    -> f []          (_:_) -> f y   Here we won't see that [] and y are the same.  Sigh! This problem-  is solved in CSE, in GHC.Core.Op.CSE.combineAlts, which does a better version+  is solved in CSE, in GHC.Core.Opt.CSE.combineAlts, which does a better version   of combineIdenticalAlts. But sadly it doesn't have the occurrence info we have   here.-  See Note [Combine case alts: awkward corner] in GHC.Core.Op.CSE).+  See Note [Combine case alts: awkward corner] in GHC.Core.Opt.CSE).  Note [Care with impossible-constructors when combining alternatives] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1420,15 +1387,14 @@   | 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+      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+        | isConLikeId fn     -> True+        | all_args_are_preds -> True+        | otherwise          -> False    where      -- See if all the arguments are PredTys (implicit params or classes)@@ -1532,7 +1498,7 @@ --    exprIsHNF            implies exprOkForSpeculation --    exprOkForSpeculation implies exprOkForSideEffects ----- See Note [PrimOp can_fail and has_side_effects] in PrimOp+-- See Note [PrimOp can_fail and has_side_effects] in GHC.Builtin.PrimOps -- and Note [Transformations affected by can_fail and has_side_effects] -- -- As an example of the considerations in this test, consider:@@ -1661,7 +1627,7 @@  -- | 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+-- This function probably belongs in GHC.Builtin.PrimOps, 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@@ -1676,10 +1642,10 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ exprOkForSpeculation accepts very special case expressions. Reason: (a ==# b) is ok-for-speculation, but the litEq rules-in GHC.Core.Op.ConstantFold convert it (a ==# 3#) to+in GHC.Core.Opt.ConstantFold convert it (a ==# 3#) to    case a of { DEFAULT -> 0#; 3# -> 1# } for excellent reasons described in-  GHC.Core.Op.ConstantFold Note [The litEq rule: converting equality to case].+  GHC.Core.Opt.ConstantFold Note [The litEq rule: converting equality to case]. So, annoyingly, we want that case expression to be ok-for-speculation too. Bother. @@ -1693,12 +1659,12 @@    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 GHC.Core.Op.SetLevels would transform the inner alternative to+  by GHC.Core.Opt.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 GHC.Core.Op.SetLevels.  To avoid this awkwardness it seems simpler+  in GHC.Core.Opt.SetLevels.  To avoid this awkwardness it seems simpler   to stick to unlifted scrutinees where the issue does not   arise. @@ -1719,7 +1685,7 @@   ----- Historical note: #15696: ---------  Previously GHC.Core.Op.SetLevels used exprOkForSpeculation to guide+  Previously GHC.Core.Opt.SetLevels used exprOkForSpeculation to guide   floating of single-alternative cases; it now uses exprIsHNF   Note [Floating single-alternative cases]. @@ -1729,8 +1695,8 @@             A -> ...             _ -> ...(case (case x of { B -> p; C -> p }) of                        I# r -> blah)...-  If GHC.Core.Op.SetLevels considers the inner nested case as-  ok-for-speculation it can do case-floating (in GHC.Core.Op.SetLevels).+  If GHC.Core.Opt.SetLevels considers the inner nested case as+  ok-for-speculation it can do case-floating (in GHC.Core.Opt.SetLevels).   So we'd float to:     case e of x { DEAFULT ->     case (case x of { B -> p; C -> p }) of I# r ->@@ -2064,7 +2030,7 @@ 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 GHC.Core.Op.Simplify.simplAlt+c.f. add_evals in GHC.Core.Opt.Simplify.simplAlt  ************************************************************************ *                                                                      *@@ -2133,7 +2099,7 @@         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 a1   -- See Note [Empty case alternatives] in GHC.Data.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@@ -2181,7 +2147,7 @@     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+    -- See Note [Empty case alternatives] in GHC.Data.TrieMap   = diffExpr top env e1 e2 ++ concat (zipWith diffAlt a1 a2)   where env' = rnBndr2 env b1 b2         diffAlt (c1, bs1, e1) (c2, bs2, e2)@@ -2333,7 +2299,7 @@  * 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 GHC.Core.Op.Simplify.Env) so we must *not* trust the+  Note [Arity robustness] in GHC.Core.Opt.Simplify.Env) so we must *not* trust the   arity when checking that 'f' is a value.  Otherwise we will   eta-reduce       f = \x. f x
compiler/GHC/CoreToIface.hs view
@@ -45,7 +45,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Iface.Syntax import GHC.Core.DataCon@@ -54,17 +54,17 @@ import GHC.Core import GHC.Core.TyCon hiding ( pprPromotionQuote ) import GHC.Core.Coercion.Axiom-import TysPrim ( eqPrimTyCon, eqReprPrimTyCon )-import TysWiredIn ( heqTyCon )+import GHC.Builtin.Types.Prim ( eqPrimTyCon, eqReprPrimTyCon )+import GHC.Builtin.Types ( heqTyCon ) import GHC.Types.Id.Make ( noinlineIdName )-import PrelNames+import GHC.Builtin.Names import GHC.Types.Name import GHC.Types.Basic import GHC.Core.Type import GHC.Core.PatSyn-import Outputable-import FastString-import Util+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Utils.Misc import GHC.Types.Var import GHC.Types.Var.Env import GHC.Types.Var.Set@@ -422,7 +422,7 @@                                (toIfaceType (idType id))                                (toIfaceIdInfo (idInfo id))                                (toIfaceJoinInfo (isJoinId_maybe id))-  -- Put into the interface file any IdInfo that GHC.Core.Op.Tidy.tidyLetBndr+  -- Put into the interface file any IdInfo that GHC.Core.Tidy.tidyLetBndr   -- has left on the Id.  See Note [IdInfo on nested let-bindings] in GHC.Iface.Syntax  toIfaceIdDetails :: IdDetails -> IfaceIdDetails
+ compiler/GHC/Data/Bag.hs view
@@ -0,0 +1,335 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+++Bag: an unordered collection with duplicates+-}++{-# LANGUAGE ScopedTypeVariables, CPP, DeriveFunctor #-}++module GHC.Data.Bag (+        Bag, -- abstract type++        emptyBag, unitBag, unionBags, unionManyBags,+        mapBag,+        elemBag, lengthBag,+        filterBag, partitionBag, partitionBagWith,+        concatBag, catBagMaybes, foldBag,+        isEmptyBag, isSingletonBag, consBag, snocBag, anyBag, allBag,+        listToBag, bagToList, mapAccumBagL,+        concatMapBag, concatMapBagPair, mapMaybeBag,+        mapBagM, mapBagM_,+        flatMapBagM, flatMapBagPairM,+        mapAndUnzipBagM, mapAccumBagLM,+        anyBagM, filterBagM+    ) where++import GHC.Prelude++import GHC.Utils.Outputable+import GHC.Utils.Misc++import GHC.Utils.Monad+import Control.Monad+import Data.Data+import Data.Maybe( mapMaybe )+import Data.List ( partition, mapAccumL )+import qualified Data.Foldable as Foldable++infixr 3 `consBag`+infixl 3 `snocBag`++data Bag a+  = EmptyBag+  | UnitBag a+  | TwoBags (Bag a) (Bag a) -- INVARIANT: neither branch is empty+  | ListBag [a]             -- INVARIANT: the list is non-empty+  deriving (Functor)++emptyBag :: Bag a+emptyBag = EmptyBag++unitBag :: a -> Bag a+unitBag  = UnitBag++lengthBag :: Bag a -> Int+lengthBag EmptyBag        = 0+lengthBag (UnitBag {})    = 1+lengthBag (TwoBags b1 b2) = lengthBag b1 + lengthBag b2+lengthBag (ListBag xs)    = length xs++elemBag :: Eq a => a -> Bag a -> Bool+elemBag _ EmptyBag        = False+elemBag x (UnitBag y)     = x == y+elemBag x (TwoBags b1 b2) = x `elemBag` b1 || x `elemBag` b2+elemBag x (ListBag ys)    = any (x ==) ys++unionManyBags :: [Bag a] -> Bag a+unionManyBags xs = foldr unionBags EmptyBag xs++-- This one is a bit stricter! The bag will get completely evaluated.++unionBags :: Bag a -> Bag a -> Bag a+unionBags EmptyBag b = b+unionBags b EmptyBag = b+unionBags b1 b2      = TwoBags b1 b2++consBag :: a -> Bag a -> Bag a+snocBag :: Bag a -> a -> Bag a++consBag elt bag = (unitBag elt) `unionBags` bag+snocBag bag elt = bag `unionBags` (unitBag elt)++isEmptyBag :: Bag a -> Bool+isEmptyBag EmptyBag = True+isEmptyBag _        = False -- NB invariants++isSingletonBag :: Bag a -> Bool+isSingletonBag EmptyBag      = False+isSingletonBag (UnitBag _)   = True+isSingletonBag (TwoBags _ _) = False          -- Neither is empty+isSingletonBag (ListBag xs)  = isSingleton xs++filterBag :: (a -> Bool) -> Bag a -> Bag a+filterBag _    EmptyBag = EmptyBag+filterBag pred b@(UnitBag val) = if pred val then b else EmptyBag+filterBag pred (TwoBags b1 b2) = sat1 `unionBags` sat2+    where sat1 = filterBag pred b1+          sat2 = filterBag pred b2+filterBag pred (ListBag vs)    = listToBag (filter pred vs)++filterBagM :: Monad m => (a -> m Bool) -> Bag a -> m (Bag a)+filterBagM _    EmptyBag = return EmptyBag+filterBagM pred b@(UnitBag val) = do+  flag <- pred val+  if flag then return b+          else return EmptyBag+filterBagM pred (TwoBags b1 b2) = do+  sat1 <- filterBagM pred b1+  sat2 <- filterBagM pred b2+  return (sat1 `unionBags` sat2)+filterBagM pred (ListBag vs) = do+  sat <- filterM pred vs+  return (listToBag sat)++allBag :: (a -> Bool) -> Bag a -> Bool+allBag _ EmptyBag        = True+allBag p (UnitBag v)     = p v+allBag p (TwoBags b1 b2) = allBag p b1 && allBag p b2+allBag p (ListBag xs)    = all p xs++anyBag :: (a -> Bool) -> Bag a -> Bool+anyBag _ EmptyBag        = False+anyBag p (UnitBag v)     = p v+anyBag p (TwoBags b1 b2) = anyBag p b1 || anyBag p b2+anyBag p (ListBag xs)    = any p xs++anyBagM :: Monad m => (a -> m Bool) -> Bag a -> m Bool+anyBagM _ EmptyBag        = return False+anyBagM p (UnitBag v)     = p v+anyBagM p (TwoBags b1 b2) = do flag <- anyBagM p b1+                               if flag then return True+                                       else anyBagM p b2+anyBagM p (ListBag xs)    = anyM p xs++concatBag :: Bag (Bag a) -> Bag a+concatBag bss = foldr add emptyBag bss+  where+    add bs rs = bs `unionBags` rs++catBagMaybes :: Bag (Maybe a) -> Bag a+catBagMaybes bs = foldr add emptyBag bs+  where+    add Nothing rs = rs+    add (Just x) rs = x `consBag` rs++partitionBag :: (a -> Bool) -> Bag a -> (Bag a {- Satisfy predictate -},+                                         Bag a {- Don't -})+partitionBag _    EmptyBag = (EmptyBag, EmptyBag)+partitionBag pred b@(UnitBag val)+    = if pred val then (b, EmptyBag) else (EmptyBag, b)+partitionBag pred (TwoBags b1 b2)+    = (sat1 `unionBags` sat2, fail1 `unionBags` fail2)+  where (sat1, fail1) = partitionBag pred b1+        (sat2, fail2) = partitionBag pred b2+partitionBag pred (ListBag vs) = (listToBag sats, listToBag fails)+  where (sats, fails) = partition pred vs+++partitionBagWith :: (a -> Either b c) -> Bag a+                    -> (Bag b {- Left  -},+                        Bag c {- Right -})+partitionBagWith _    EmptyBag = (EmptyBag, EmptyBag)+partitionBagWith pred (UnitBag val)+    = case pred val of+         Left a  -> (UnitBag a, EmptyBag)+         Right b -> (EmptyBag, UnitBag b)+partitionBagWith pred (TwoBags b1 b2)+    = (sat1 `unionBags` sat2, fail1 `unionBags` fail2)+  where (sat1, fail1) = partitionBagWith pred b1+        (sat2, fail2) = partitionBagWith pred b2+partitionBagWith pred (ListBag vs) = (listToBag sats, listToBag fails)+  where (sats, fails) = partitionWith pred vs++foldBag :: (r -> r -> r) -- Replace TwoBags with this; should be associative+        -> (a -> r)      -- Replace UnitBag with this+        -> r             -- Replace EmptyBag with this+        -> Bag a+        -> r++{- Standard definition+foldBag t u e EmptyBag        = e+foldBag t u e (UnitBag x)     = u x+foldBag t u e (TwoBags b1 b2) = (foldBag t u e b1) `t` (foldBag t u e b2)+foldBag t u e (ListBag xs)    = foldr (t.u) e xs+-}++-- More tail-recursive definition, exploiting associativity of "t"+foldBag _ _ e EmptyBag        = e+foldBag t u e (UnitBag x)     = u x `t` e+foldBag t u e (TwoBags b1 b2) = foldBag t u (foldBag t u e b2) b1+foldBag t u e (ListBag xs)    = foldr (t.u) e xs++mapBag :: (a -> b) -> Bag a -> Bag b+mapBag = fmap++concatMapBag :: (a -> Bag b) -> Bag a -> Bag b+concatMapBag _ EmptyBag        = EmptyBag+concatMapBag f (UnitBag x)     = f x+concatMapBag f (TwoBags b1 b2) = unionBags (concatMapBag f b1) (concatMapBag f b2)+concatMapBag f (ListBag xs)    = foldr (unionBags . f) emptyBag xs++concatMapBagPair :: (a -> (Bag b, Bag c)) -> Bag a -> (Bag b, Bag c)+concatMapBagPair _ EmptyBag        = (EmptyBag, EmptyBag)+concatMapBagPair f (UnitBag x)     = f x+concatMapBagPair f (TwoBags b1 b2) = (unionBags r1 r2, unionBags s1 s2)+  where+    (r1, s1) = concatMapBagPair f b1+    (r2, s2) = concatMapBagPair f b2+concatMapBagPair f (ListBag xs)    = foldr go (emptyBag, emptyBag) xs+  where+    go a (s1, s2) = (unionBags r1 s1, unionBags r2 s2)+      where+        (r1, r2) = f a++mapMaybeBag :: (a -> Maybe b) -> Bag a -> Bag b+mapMaybeBag _ EmptyBag        = EmptyBag+mapMaybeBag f (UnitBag x)     = case f x of+                                  Nothing -> EmptyBag+                                  Just y  -> UnitBag y+mapMaybeBag f (TwoBags b1 b2) = unionBags (mapMaybeBag f b1) (mapMaybeBag f b2)+mapMaybeBag f (ListBag xs)    = ListBag (mapMaybe f xs)++mapBagM :: Monad m => (a -> m b) -> Bag a -> m (Bag b)+mapBagM _ EmptyBag        = return EmptyBag+mapBagM f (UnitBag x)     = do r <- f x+                               return (UnitBag r)+mapBagM f (TwoBags b1 b2) = do r1 <- mapBagM f b1+                               r2 <- mapBagM f b2+                               return (TwoBags r1 r2)+mapBagM f (ListBag    xs) = do rs <- mapM f xs+                               return (ListBag rs)++mapBagM_ :: Monad m => (a -> m b) -> Bag a -> m ()+mapBagM_ _ EmptyBag        = return ()+mapBagM_ f (UnitBag x)     = f x >> return ()+mapBagM_ f (TwoBags b1 b2) = mapBagM_ f b1 >> mapBagM_ f b2+mapBagM_ f (ListBag    xs) = mapM_ f xs++flatMapBagM :: Monad m => (a -> m (Bag b)) -> Bag a -> m (Bag b)+flatMapBagM _ EmptyBag        = return EmptyBag+flatMapBagM f (UnitBag x)     = f x+flatMapBagM f (TwoBags b1 b2) = do r1 <- flatMapBagM f b1+                                   r2 <- flatMapBagM f b2+                                   return (r1 `unionBags` r2)+flatMapBagM f (ListBag    xs) = foldrM k EmptyBag xs+  where+    k x b2 = do { b1 <- f x; return (b1 `unionBags` b2) }++flatMapBagPairM :: Monad m => (a -> m (Bag b, Bag c)) -> Bag a -> m (Bag b, Bag c)+flatMapBagPairM _ EmptyBag        = return (EmptyBag, EmptyBag)+flatMapBagPairM f (UnitBag x)     = f x+flatMapBagPairM f (TwoBags b1 b2) = do (r1,s1) <- flatMapBagPairM f b1+                                       (r2,s2) <- flatMapBagPairM f b2+                                       return (r1 `unionBags` r2, s1 `unionBags` s2)+flatMapBagPairM f (ListBag    xs) = foldrM k (EmptyBag, EmptyBag) xs+  where+    k x (r2,s2) = do { (r1,s1) <- f x+                     ; return (r1 `unionBags` r2, s1 `unionBags` s2) }++mapAndUnzipBagM :: Monad m => (a -> m (b,c)) -> Bag a -> m (Bag b, Bag c)+mapAndUnzipBagM _ EmptyBag        = return (EmptyBag, EmptyBag)+mapAndUnzipBagM f (UnitBag x)     = do (r,s) <- f x+                                       return (UnitBag r, UnitBag s)+mapAndUnzipBagM f (TwoBags b1 b2) = do (r1,s1) <- mapAndUnzipBagM f b1+                                       (r2,s2) <- mapAndUnzipBagM f b2+                                       return (TwoBags r1 r2, TwoBags s1 s2)+mapAndUnzipBagM f (ListBag xs)    = do ts <- mapM f xs+                                       let (rs,ss) = unzip ts+                                       return (ListBag rs, ListBag ss)++mapAccumBagL ::(acc -> x -> (acc, y)) -- ^ combining function+            -> acc                    -- ^ initial state+            -> Bag x                  -- ^ inputs+            -> (acc, Bag y)           -- ^ final state, outputs+mapAccumBagL _ s EmptyBag        = (s, EmptyBag)+mapAccumBagL f s (UnitBag x)     = let (s1, x1) = f s x in (s1, UnitBag x1)+mapAccumBagL f s (TwoBags b1 b2) = let (s1, b1') = mapAccumBagL f s  b1+                                       (s2, b2') = mapAccumBagL f s1 b2+                                   in (s2, TwoBags b1' b2')+mapAccumBagL f s (ListBag xs)    = let (s', xs') = mapAccumL f s xs+                                   in (s', ListBag xs')++mapAccumBagLM :: Monad m+            => (acc -> x -> m (acc, y)) -- ^ combining function+            -> acc                      -- ^ initial state+            -> Bag x                    -- ^ inputs+            -> m (acc, Bag y)           -- ^ final state, outputs+mapAccumBagLM _ s EmptyBag        = return (s, EmptyBag)+mapAccumBagLM f s (UnitBag x)     = do { (s1, x1) <- f s x; return (s1, UnitBag x1) }+mapAccumBagLM f s (TwoBags b1 b2) = do { (s1, b1') <- mapAccumBagLM f s  b1+                                       ; (s2, b2') <- mapAccumBagLM f s1 b2+                                       ; return (s2, TwoBags b1' b2') }+mapAccumBagLM f s (ListBag xs)    = do { (s', xs') <- mapAccumLM f s xs+                                       ; return (s', ListBag xs') }++listToBag :: [a] -> Bag a+listToBag [] = EmptyBag+listToBag [x] = UnitBag x+listToBag vs = ListBag vs++bagToList :: Bag a -> [a]+bagToList b = foldr (:) [] b++instance (Outputable a) => Outputable (Bag a) where+    ppr bag = braces (pprWithCommas ppr (bagToList bag))++instance Data a => Data (Bag a) where+  gfoldl k z b = z listToBag `k` bagToList b -- traverse abstract type abstractly+  toConstr _   = abstractConstr $ "Bag("++show (typeOf (undefined::a))++")"+  gunfold _ _  = error "gunfold"+  dataTypeOf _ = mkNoRepType "Bag"+  dataCast1 x  = gcast1 x++instance Foldable.Foldable Bag where+  foldr _ z EmptyBag        = z+  foldr k z (UnitBag x)     = k x z+  foldr k z (TwoBags b1 b2) = foldr k (foldr k z b2) b1+  foldr k z (ListBag xs)    = foldr k z xs++  foldl _ z EmptyBag        = z+  foldl k z (UnitBag x)     = k z x+  foldl k z (TwoBags b1 b2) = foldl k (foldl k z b1) b2+  foldl k z (ListBag xs)    = foldl k z xs++  foldl' _ z EmptyBag        = z+  foldl' k z (UnitBag x)     = k z x+  foldl' k z (TwoBags b1 b2) = let r1 = foldl' k z b1 in seq r1 $ foldl' k r1 b2+  foldl' k z (ListBag xs)    = foldl' k z xs++instance Traversable Bag where+  traverse _ EmptyBag        = pure EmptyBag+  traverse f (UnitBag x)     = UnitBag <$> f x+  traverse f (TwoBags b1 b2) = TwoBags <$> traverse f b1 <*> traverse f b2+  traverse f (ListBag xs)    = ListBag <$> traverse f xs
+ compiler/GHC/Data/BooleanFormula.hs view
@@ -0,0 +1,262 @@+{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable,+             DeriveTraversable #-}++--------------------------------------------------------------------------------+-- | Boolean formulas without quantifiers and without negation.+-- Such a formula consists of variables, conjunctions (and), and disjunctions (or).+--+-- This module is used to represent minimal complete definitions for classes.+--+module GHC.Data.BooleanFormula (+        BooleanFormula(..), LBooleanFormula,+        mkFalse, mkTrue, mkAnd, mkOr, mkVar,+        isFalse, isTrue,+        eval, simplify, isUnsatisfied,+        implies, impliesAtom,+        pprBooleanFormula, pprBooleanFormulaNice+  ) where++import GHC.Prelude++import Data.List ( nub, intersperse )+import Data.Data++import GHC.Utils.Monad+import GHC.Utils.Outputable+import GHC.Utils.Binary+import GHC.Types.SrcLoc+import GHC.Types.Unique+import GHC.Types.Unique.Set++----------------------------------------------------------------------+-- Boolean formula type and smart constructors+----------------------------------------------------------------------++type LBooleanFormula a = Located (BooleanFormula a)++data BooleanFormula a = Var a | And [LBooleanFormula a] | Or [LBooleanFormula a]+                      | Parens (LBooleanFormula a)+  deriving (Eq, Data, Functor, Foldable, Traversable)++mkVar :: a -> BooleanFormula a+mkVar = Var++mkFalse, mkTrue :: BooleanFormula a+mkFalse = Or []+mkTrue = And []++-- Convert a Bool to a BooleanFormula+mkBool :: Bool -> BooleanFormula a+mkBool False = mkFalse+mkBool True  = mkTrue++-- Make a conjunction, and try to simplify+mkAnd :: Eq a => [LBooleanFormula a] -> BooleanFormula a+mkAnd = maybe mkFalse (mkAnd' . nub) . concatMapM fromAnd+  where+  -- See Note [Simplification of BooleanFormulas]+  fromAnd :: LBooleanFormula a -> Maybe [LBooleanFormula a]+  fromAnd (L _ (And xs)) = Just xs+     -- assume that xs are already simplified+     -- otherwise we would need: fromAnd (And xs) = concat <$> traverse fromAnd xs+  fromAnd (L _ (Or [])) = Nothing+     -- in case of False we bail out, And [..,mkFalse,..] == mkFalse+  fromAnd x = Just [x]+  mkAnd' [x] = unLoc x+  mkAnd' xs = And xs++mkOr :: Eq a => [LBooleanFormula a] -> BooleanFormula a+mkOr = maybe mkTrue (mkOr' . nub) . concatMapM fromOr+  where+  -- See Note [Simplification of BooleanFormulas]+  fromOr (L _ (Or xs)) = Just xs+  fromOr (L _ (And [])) = Nothing+  fromOr x = Just [x]+  mkOr' [x] = unLoc x+  mkOr' xs = Or xs+++{-+Note [Simplification of BooleanFormulas]+~~~~~~~~~~~~~~~~~~~~~~+The smart constructors (`mkAnd` and `mkOr`) do some attempt to simplify expressions. In particular,+ 1. Collapsing nested ands and ors, so+     `(mkAnd [x, And [y,z]]`+    is represented as+     `And [x,y,z]`+    Implemented by `fromAnd`/`fromOr`+ 2. Collapsing trivial ands and ors, so+     `mkAnd [x]` becomes just `x`.+    Implemented by mkAnd' / mkOr'+ 3. Conjunction with false, disjunction with true is simplified, i.e.+     `mkAnd [mkFalse,x]` becomes `mkFalse`.+ 4. Common subexpression elimination:+     `mkAnd [x,x,y]` is reduced to just `mkAnd [x,y]`.++This simplification is not exhaustive, in the sense that it will not produce+the smallest possible equivalent expression. For example,+`Or [And [x,y], And [x]]` could be simplified to `And [x]`, but it currently+is not. A general simplifier would need to use something like BDDs.++The reason behind the (crude) simplifier is to make for more user friendly+error messages. E.g. for the code+  > class Foo a where+  >     {-# MINIMAL bar, (foo, baq | foo, quux) #-}+  > instance Foo Int where+  >     bar = ...+  >     baz = ...+  >     quux = ...+We don't show a ridiculous error message like+    Implement () and (either (`foo' and ()) or (`foo' and ()))+-}++----------------------------------------------------------------------+-- Evaluation and simplification+----------------------------------------------------------------------++isFalse :: BooleanFormula a -> Bool+isFalse (Or []) = True+isFalse _ = False++isTrue :: BooleanFormula a -> Bool+isTrue (And []) = True+isTrue _ = False++eval :: (a -> Bool) -> BooleanFormula a -> Bool+eval f (Var x)  = f x+eval f (And xs) = all (eval f . unLoc) xs+eval f (Or xs)  = any (eval f . unLoc) xs+eval f (Parens x) = eval f (unLoc x)++-- Simplify a boolean formula.+-- The argument function should give the truth of the atoms, or Nothing if undecided.+simplify :: Eq a => (a -> Maybe Bool) -> BooleanFormula a -> BooleanFormula a+simplify f (Var a) = case f a of+  Nothing -> Var a+  Just b  -> mkBool b+simplify f (And xs) = mkAnd (map (\(L l x) -> L l (simplify f x)) xs)+simplify f (Or xs) = mkOr (map (\(L l x) -> L l (simplify f x)) xs)+simplify f (Parens x) = simplify f (unLoc x)++-- Test if a boolean formula is satisfied when the given values are assigned to the atoms+-- if it is, returns Nothing+-- if it is not, return (Just remainder)+isUnsatisfied :: Eq a => (a -> Bool) -> BooleanFormula a -> Maybe (BooleanFormula a)+isUnsatisfied f bf+    | isTrue bf' = Nothing+    | otherwise  = Just bf'+  where+  f' x = if f x then Just True else Nothing+  bf' = simplify f' bf++-- prop_simplify:+--   eval f x == True   <==>  isTrue  (simplify (Just . f) x)+--   eval f x == False  <==>  isFalse (simplify (Just . f) x)++-- If the boolean formula holds, does that mean that the given atom is always true?+impliesAtom :: Eq a => BooleanFormula a -> a -> Bool+Var x  `impliesAtom` y = x == y+And xs `impliesAtom` y = any (\x -> (unLoc x) `impliesAtom` y) xs+           -- we have all of xs, so one of them implying y is enough+Or  xs `impliesAtom` y = all (\x -> (unLoc x) `impliesAtom` y) xs+Parens x `impliesAtom` y = (unLoc x) `impliesAtom` y++implies :: Uniquable a => BooleanFormula a -> BooleanFormula a -> Bool+implies e1 e2 = go (Clause emptyUniqSet [e1]) (Clause emptyUniqSet [e2])+  where+    go :: Uniquable a => Clause a -> Clause a -> Bool+    go l@Clause{ clauseExprs = hyp:hyps } r =+        case hyp of+            Var x | memberClauseAtoms x r -> True+                  | otherwise -> go (extendClauseAtoms l x) { clauseExprs = hyps } r+            Parens hyp' -> go l { clauseExprs = unLoc hyp':hyps }     r+            And hyps'  -> go l { clauseExprs = map unLoc hyps' ++ hyps } r+            Or hyps'   -> all (\hyp' -> go l { clauseExprs = unLoc hyp':hyps } r) hyps'+    go l r@Clause{ clauseExprs = con:cons } =+        case con of+            Var x | memberClauseAtoms x l -> True+                  | otherwise -> go l (extendClauseAtoms r x) { clauseExprs = cons }+            Parens con' -> go l r { clauseExprs = unLoc con':cons }+            And cons'   -> all (\con' -> go l r { clauseExprs = unLoc con':cons }) cons'+            Or cons'    -> go l r { clauseExprs = map unLoc cons' ++ cons }+    go _ _ = False++-- A small sequent calculus proof engine.+data Clause a = Clause {+        clauseAtoms :: UniqSet a,+        clauseExprs :: [BooleanFormula a]+    }+extendClauseAtoms :: Uniquable a => Clause a -> a -> Clause a+extendClauseAtoms c x = c { clauseAtoms = addOneToUniqSet (clauseAtoms c) x }++memberClauseAtoms :: Uniquable a => a -> Clause a -> Bool+memberClauseAtoms x c = x `elementOfUniqSet` clauseAtoms c++----------------------------------------------------------------------+-- Pretty printing+----------------------------------------------------------------------++-- Pretty print a BooleanFormula,+-- using the arguments as pretty printers for Var, And and Or respectively+pprBooleanFormula' :: (Rational -> a -> SDoc)+                   -> (Rational -> [SDoc] -> SDoc)+                   -> (Rational -> [SDoc] -> SDoc)+                   -> Rational -> BooleanFormula a -> SDoc+pprBooleanFormula' pprVar pprAnd pprOr = go+  where+  go p (Var x)  = pprVar p x+  go p (And []) = cparen (p > 0) $ empty+  go p (And xs) = pprAnd p (map (go 3 . unLoc) xs)+  go _ (Or  []) = keyword $ text "FALSE"+  go p (Or  xs) = pprOr p (map (go 2 . unLoc) xs)+  go p (Parens x) = go p (unLoc x)++-- Pretty print in source syntax, "a | b | c,d,e"+pprBooleanFormula :: (Rational -> a -> SDoc) -> Rational -> BooleanFormula a -> SDoc+pprBooleanFormula pprVar = pprBooleanFormula' pprVar pprAnd pprOr+  where+  pprAnd p = cparen (p > 3) . fsep . punctuate comma+  pprOr  p = cparen (p > 2) . fsep . intersperse vbar++-- Pretty print human in readable format, "either `a' or `b' or (`c', `d' and `e')"?+pprBooleanFormulaNice :: Outputable a => BooleanFormula a -> SDoc+pprBooleanFormulaNice = pprBooleanFormula' pprVar pprAnd pprOr 0+  where+  pprVar _ = quotes . ppr+  pprAnd p = cparen (p > 1) . pprAnd'+  pprAnd' [] = empty+  pprAnd' [x,y] = x <+> text "and" <+> y+  pprAnd' xs@(_:_) = fsep (punctuate comma (init xs)) <> text ", and" <+> last xs+  pprOr p xs = cparen (p > 1) $ text "either" <+> sep (intersperse (text "or") xs)++instance (OutputableBndr a) => Outputable (BooleanFormula a) where+  ppr = pprBooleanFormulaNormal++pprBooleanFormulaNormal :: (OutputableBndr a)+                        => BooleanFormula a -> SDoc+pprBooleanFormulaNormal = go+  where+    go (Var x)    = pprPrefixOcc x+    go (And xs)   = fsep $ punctuate comma (map (go . unLoc) xs)+    go (Or [])    = keyword $ text "FALSE"+    go (Or xs)    = fsep $ intersperse vbar (map (go . unLoc) xs)+    go (Parens x) = parens (go $ unLoc x)+++----------------------------------------------------------------------+-- Binary+----------------------------------------------------------------------++instance Binary a => Binary (BooleanFormula a) where+  put_ bh (Var x)    = putByte bh 0 >> put_ bh x+  put_ bh (And xs)   = putByte bh 1 >> put_ bh xs+  put_ bh (Or  xs)   = putByte bh 2 >> put_ bh xs+  put_ bh (Parens x) = putByte bh 3 >> put_ bh x++  get bh = do+    h <- getByte bh+    case h of+      0 -> Var    <$> get bh+      1 -> And    <$> get bh+      2 -> Or     <$> get bh+      _ -> Parens <$> get bh
+ compiler/GHC/Data/EnumSet.hs view
@@ -0,0 +1,35 @@+-- | A tiny wrapper around 'IntSet.IntSet' for representing sets of 'Enum'+-- things.+module GHC.Data.EnumSet+    ( EnumSet+    , member+    , insert+    , delete+    , toList+    , fromList+    , empty+    ) where++import GHC.Prelude++import qualified Data.IntSet as IntSet++newtype EnumSet a = EnumSet IntSet.IntSet++member :: Enum a => a -> EnumSet a -> Bool+member x (EnumSet s) = IntSet.member (fromEnum x) s++insert :: Enum a => a -> EnumSet a -> EnumSet a+insert x (EnumSet s) = EnumSet $ IntSet.insert (fromEnum x) s++delete :: Enum a => a -> EnumSet a -> EnumSet a+delete x (EnumSet s) = EnumSet $ IntSet.delete (fromEnum x) s++toList :: Enum a => EnumSet a -> [a]+toList (EnumSet s) = map toEnum $ IntSet.toList s++fromList :: Enum a => [a] -> EnumSet a+fromList = EnumSet . IntSet.fromList . map fromEnum++empty :: EnumSet a+empty = EnumSet IntSet.empty
+ compiler/GHC/Data/FastMutInt.hs view
@@ -0,0 +1,61 @@+{-# LANGUAGE BangPatterns, MagicHash, UnboxedTuples #-}+{-# OPTIONS_GHC -O2 #-}+-- We always optimise this, otherwise performance of a non-optimised+-- compiler is severely affected+--+-- (c) The University of Glasgow 2002-2006+--+-- Unboxed mutable Ints++module GHC.Data.FastMutInt(+        FastMutInt, newFastMutInt,+        readFastMutInt, writeFastMutInt,++        FastMutPtr, newFastMutPtr,+        readFastMutPtr, writeFastMutPtr+  ) where++import GHC.Prelude++import Data.Bits+import GHC.Base+import GHC.Ptr++newFastMutInt :: IO FastMutInt+readFastMutInt :: FastMutInt -> IO Int+writeFastMutInt :: FastMutInt -> Int -> IO ()++newFastMutPtr :: IO FastMutPtr+readFastMutPtr :: FastMutPtr -> IO (Ptr a)+writeFastMutPtr :: FastMutPtr -> Ptr a -> IO ()++data FastMutInt = FastMutInt (MutableByteArray# RealWorld)++newFastMutInt = IO $ \s ->+  case newByteArray# size s of { (# s, arr #) ->+  (# s, FastMutInt arr #) }+  where !(I# size) = finiteBitSize (0 :: Int)++readFastMutInt (FastMutInt arr) = IO $ \s ->+  case readIntArray# arr 0# s of { (# s, i #) ->+  (# s, I# i #) }++writeFastMutInt (FastMutInt arr) (I# i) = IO $ \s ->+  case writeIntArray# arr 0# i s of { s ->+  (# s, () #) }++data FastMutPtr = FastMutPtr (MutableByteArray# RealWorld)++newFastMutPtr = IO $ \s ->+  case newByteArray# size s of { (# s, arr #) ->+  (# s, FastMutPtr arr #) }+  -- GHC assumes 'sizeof (Int) == sizeof (Ptr a)'+  where !(I# size) = finiteBitSize (0 :: Int)++readFastMutPtr (FastMutPtr arr) = IO $ \s ->+  case readAddrArray# arr 0# s of { (# s, i #) ->+  (# s, Ptr i #) }++writeFastMutPtr (FastMutPtr arr) (Ptr i) = IO $ \s ->+  case writeAddrArray# arr 0# i s of { s ->+  (# s, () #) }
+ compiler/GHC/Data/FastString.hs view
@@ -0,0 +1,693 @@+-- (c) The University of Glasgow, 1997-2006++{-# LANGUAGE BangPatterns, CPP, MagicHash, UnboxedTuples,+    GeneralizedNewtypeDeriving #-}+{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}+-- We always optimise this, otherwise performance of a non-optimised+-- compiler is severely affected++-- |+-- There are two principal string types used internally by GHC:+--+-- ['FastString']+--+--   * A compact, hash-consed, representation of character strings.+--   * Comparison is O(1), and you can get a 'Unique.Unique' from them.+--   * Generated by 'fsLit'.+--   * Turn into 'Outputable.SDoc' with 'Outputable.ftext'.+--+-- ['PtrString']+--+--   * Pointer and size of a Latin-1 encoded string.+--   * Practically no operations.+--   * Outputting them is fast.+--   * Generated by 'sLit'.+--   * Turn into 'Outputable.SDoc' with 'Outputable.ptext'+--   * Requires manual memory management.+--     Improper use may lead to memory leaks or dangling pointers.+--   * It assumes Latin-1 as the encoding, therefore it cannot represent+--     arbitrary Unicode strings.+--+-- Use 'PtrString' unless you want the facilities of 'FastString'.+module GHC.Data.FastString+       (+        -- * ByteString+        bytesFS,            -- :: FastString -> ByteString+        fastStringToByteString, -- = bytesFS (kept for haddock)+        mkFastStringByteString,+        fastZStringToByteString,+        unsafeMkByteString,++        -- * FastZString+        FastZString,+        hPutFZS,+        zString,+        lengthFZS,++        -- * FastStrings+        FastString(..),     -- not abstract, for now.++        -- ** Construction+        fsLit,+        mkFastString,+        mkFastStringBytes,+        mkFastStringByteList,+        mkFastStringForeignPtr,+        mkFastString#,++        -- ** Deconstruction+        unpackFS,           -- :: FastString -> String++        -- ** Encoding+        zEncodeFS,++        -- ** Operations+        uniqueOfFS,+        lengthFS,+        nullFS,+        appendFS,+        headFS,+        tailFS,+        concatFS,+        consFS,+        nilFS,+        isUnderscoreFS,++        -- ** Outputting+        hPutFS,++        -- ** Internal+        getFastStringTable,+        getFastStringZEncCounter,++        -- * PtrStrings+        PtrString (..),++        -- ** Construction+        sLit,+        mkPtrString#,+        mkPtrString,++        -- ** Deconstruction+        unpackPtrString,++        -- ** Operations+        lengthPS+       ) where++#include "HsVersions.h"++import GHC.Prelude as Prelude++import GHC.Utils.Encoding+import GHC.Utils.IO.Unsafe+import GHC.Utils.Panic.Plain+import GHC.Utils.Misc++import Control.Concurrent.MVar+import Control.DeepSeq+import Control.Monad+import Data.ByteString (ByteString)+import qualified Data.ByteString          as BS+import qualified Data.ByteString.Char8    as BSC+import qualified Data.ByteString.Internal as BS+import qualified Data.ByteString.Unsafe   as BS+import Foreign.C+import GHC.Exts+import System.IO+import Data.Data+import Data.IORef+import Data.Char+import Data.Semigroup as Semi++import GHC.IO++import Foreign++#if GHC_STAGE >= 2+import GHC.Conc.Sync    (sharedCAF)+#endif++import GHC.Base         ( unpackCString#, unpackNBytes# )+++-- | Gives the UTF-8 encoded bytes corresponding to a 'FastString'+bytesFS :: FastString -> ByteString+bytesFS f = fs_bs f++{-# DEPRECATED fastStringToByteString "Use `bytesFS` instead" #-}+fastStringToByteString :: FastString -> ByteString+fastStringToByteString = bytesFS++fastZStringToByteString :: FastZString -> ByteString+fastZStringToByteString (FastZString bs) = bs++-- This will drop information if any character > '\xFF'+unsafeMkByteString :: String -> ByteString+unsafeMkByteString = BSC.pack++hashFastString :: FastString -> Int+hashFastString (FastString _ _ bs _)+    = inlinePerformIO $ BS.unsafeUseAsCStringLen bs $ \(ptr, len) ->+      return $ hashStr (castPtr ptr) len++-- -----------------------------------------------------------------------------++newtype FastZString = FastZString ByteString+  deriving NFData++hPutFZS :: Handle -> FastZString -> IO ()+hPutFZS handle (FastZString bs) = BS.hPut handle bs++zString :: FastZString -> String+zString (FastZString bs) =+    inlinePerformIO $ BS.unsafeUseAsCStringLen bs peekCAStringLen++lengthFZS :: FastZString -> Int+lengthFZS (FastZString bs) = BS.length bs++mkFastZStringString :: String -> FastZString+mkFastZStringString str = FastZString (BSC.pack str)++-- -----------------------------------------------------------------------------++{-| A 'FastString' is a UTF-8 encoded string together with a unique ID. All+'FastString's are stored in a global hashtable to support fast O(1)+comparison.++It is also associated with a lazy reference to the Z-encoding+of this string which is used by the compiler internally.+-}+data FastString = FastString {+      uniq    :: {-# UNPACK #-} !Int, -- unique id+      n_chars :: {-# UNPACK #-} !Int, -- number of chars+      fs_bs   :: {-# UNPACK #-} !ByteString,+      fs_zenc :: FastZString+      -- ^ Lazily computed z-encoding of this string.+      --+      -- Since 'FastString's are globally memoized this is computed at most+      -- once for any given string.+  }++instance Eq FastString where+  f1 == f2  =  uniq f1 == uniq f2++instance Ord FastString where+    -- Compares lexicographically, not by unique+    a <= b = case cmpFS a b of { LT -> True;  EQ -> True;  GT -> False }+    a <  b = case cmpFS a b of { LT -> True;  EQ -> False; GT -> False }+    a >= b = case cmpFS a b of { LT -> False; EQ -> True;  GT -> True  }+    a >  b = case cmpFS a b of { LT -> False; EQ -> False; GT -> True  }+    max x y | x >= y    =  x+            | otherwise =  y+    min x y | x <= y    =  x+            | otherwise =  y+    compare a b = cmpFS a b++instance IsString FastString where+    fromString = fsLit++instance Semi.Semigroup FastString where+    (<>) = appendFS++instance Monoid FastString where+    mempty = nilFS+    mappend = (Semi.<>)+    mconcat = concatFS++instance Show FastString where+   show fs = show (unpackFS fs)++instance Data FastString where+  -- don't traverse?+  toConstr _   = abstractConstr "FastString"+  gunfold _ _  = error "gunfold"+  dataTypeOf _ = mkNoRepType "FastString"++instance NFData FastString where+  rnf fs = seq fs ()++cmpFS :: FastString -> FastString -> Ordering+cmpFS f1@(FastString u1 _ _ _) f2@(FastString u2 _ _ _) =+  if u1 == u2 then EQ else+  compare (bytesFS f1) (bytesFS f2)++foreign import ccall unsafe "memcmp"+  memcmp :: Ptr a -> Ptr b -> Int -> IO Int++-- -----------------------------------------------------------------------------+-- Construction++{-+Internally, the compiler will maintain a fast string symbol table, providing+sharing and fast comparison. Creation of new @FastString@s then covertly does a+lookup, re-using the @FastString@ if there was a hit.++The design of the FastString hash table allows for lockless concurrent reads+and updates to multiple buckets with low synchronization overhead.++See Note [Updating the FastString table] on how it's updated.+-}+data FastStringTable = FastStringTable+  {-# UNPACK #-} !(IORef Int) -- the unique ID counter shared with all buckets+  {-# UNPACK #-} !(IORef Int) -- number of computed z-encodings for all buckets+  (Array# (IORef FastStringTableSegment)) -- concurrent segments++data FastStringTableSegment = FastStringTableSegment+  {-# UNPACK #-} !(MVar ()) -- the lock for write in each segment+  {-# UNPACK #-} !(IORef Int) -- the number of elements+  (MutableArray# RealWorld [FastString]) -- buckets in this segment++{-+Following parameters are determined based on:++* Benchmark based on testsuite/tests/utils/should_run/T14854.hs+* Stats of @echo :browse | ghc --interactive -dfaststring-stats >/dev/null@:+  on 2018-10-24, we have 13920 entries.+-}+segmentBits, numSegments, segmentMask, initialNumBuckets :: Int+segmentBits = 8+numSegments = 256   -- bit segmentBits+segmentMask = 0xff  -- bit segmentBits - 1+initialNumBuckets = 64++hashToSegment# :: Int# -> Int#+hashToSegment# hash# = hash# `andI#` segmentMask#+  where+    !(I# segmentMask#) = segmentMask++hashToIndex# :: MutableArray# RealWorld [FastString] -> Int# -> Int#+hashToIndex# buckets# hash# =+  (hash# `uncheckedIShiftRL#` segmentBits#) `remInt#` size#+  where+    !(I# segmentBits#) = segmentBits+    size# = sizeofMutableArray# buckets#++maybeResizeSegment :: IORef FastStringTableSegment -> IO FastStringTableSegment+maybeResizeSegment segmentRef = do+  segment@(FastStringTableSegment lock counter old#) <- readIORef segmentRef+  let oldSize# = sizeofMutableArray# old#+      newSize# = oldSize# *# 2#+  (I# n#) <- readIORef counter+  if isTrue# (n# <# newSize#) -- maximum load of 1+  then return segment+  else do+    resizedSegment@(FastStringTableSegment _ _ new#) <- IO $ \s1# ->+      case newArray# newSize# [] s1# of+        (# s2#, arr# #) -> (# s2#, FastStringTableSegment lock counter arr# #)+    forM_ [0 .. (I# oldSize#) - 1] $ \(I# i#) -> do+      fsList <- IO $ readArray# old# i#+      forM_ fsList $ \fs -> do+        let -- Shall we store in hash value in FastString instead?+            !(I# hash#) = hashFastString fs+            idx# = hashToIndex# new# hash#+        IO $ \s1# ->+          case readArray# new# idx# s1# of+            (# s2#, bucket #) -> case writeArray# new# idx# (fs: bucket) s2# of+              s3# -> (# s3#, () #)+    writeIORef segmentRef resizedSegment+    return resizedSegment++{-# NOINLINE stringTable #-}+stringTable :: FastStringTable+stringTable = unsafePerformIO $ do+  let !(I# numSegments#) = numSegments+      !(I# initialNumBuckets#) = initialNumBuckets+      loop a# i# s1#+        | isTrue# (i# ==# numSegments#) = s1#+        | otherwise = case newMVar () `unIO` s1# of+            (# s2#, lock #) -> case newIORef 0 `unIO` s2# of+              (# s3#, counter #) -> case newArray# initialNumBuckets# [] s3# of+                (# s4#, buckets# #) -> case newIORef+                    (FastStringTableSegment lock counter buckets#) `unIO` s4# of+                  (# s5#, segment #) -> case writeArray# a# i# segment s5# of+                    s6# -> loop a# (i# +# 1#) s6#+  uid <- newIORef 603979776 -- ord '$' * 0x01000000+  n_zencs <- newIORef 0+  tab <- IO $ \s1# ->+    case newArray# numSegments# (panic "string_table") s1# of+      (# s2#, arr# #) -> case loop arr# 0# s2# of+        s3# -> case unsafeFreezeArray# arr# s3# of+          (# s4#, segments# #) ->+            (# s4#, FastStringTable uid n_zencs segments# #)++  -- use the support wired into the RTS to share this CAF among all images of+  -- libHSghc+#if GHC_STAGE < 2+  return tab+#else+  sharedCAF tab getOrSetLibHSghcFastStringTable++-- from the RTS; thus we cannot use this mechanism when GHC_STAGE<2; the previous+-- RTS might not have this symbol+foreign import ccall unsafe "getOrSetLibHSghcFastStringTable"+  getOrSetLibHSghcFastStringTable :: Ptr a -> IO (Ptr a)+#endif++{-++We include the FastString table in the `sharedCAF` mechanism because we'd like+FastStrings created by a Core plugin to have the same uniques as corresponding+strings created by the host compiler itself.  For example, this allows plugins+to lookup known names (eg `mkTcOcc "MySpecialType"`) in the GlobalRdrEnv or+even re-invoke the parser.++In particular, the following little sanity test was failing in a plugin+prototyping safe newtype-coercions: GHC.NT.Type.NT was imported, but could not+be looked up /by the plugin/.++   let rdrName = mkModuleName "GHC.NT.Type" `mkRdrQual` mkTcOcc "NT"+   putMsgS $ showSDoc dflags $ ppr $ lookupGRE_RdrName rdrName $ mg_rdr_env guts++`mkTcOcc` involves the lookup (or creation) of a FastString.  Since the+plugin's FastString.string_table is empty, constructing the RdrName also+allocates new uniques for the FastStrings "GHC.NT.Type" and "NT".  These+uniques are almost certainly unequal to the ones that the host compiler+originally assigned to those FastStrings.  Thus the lookup fails since the+domain of the GlobalRdrEnv is affected by the RdrName's OccName's FastString's+unique.++Maintaining synchronization of the two instances of this global is rather+difficult because of the uses of `unsafePerformIO` in this module.  Not+synchronizing them risks breaking the rather major invariant that two+FastStrings with the same unique have the same string. Thus we use the+lower-level `sharedCAF` mechanism that relies on Globals.c.++-}++mkFastString# :: Addr# -> FastString+mkFastString# a# = mkFastStringBytes ptr (ptrStrLength ptr)+  where ptr = Ptr a#++{- Note [Updating the FastString table]++We use a concurrent hashtable which contains multiple segments, each hash value+always maps to the same segment. Read is lock-free, write to the a segment+should acquire a lock for that segment to avoid race condition, writes to+different segments are independent.++The procedure goes like this:++1. Find out which segment to operate on based on the hash value+2. Read the relevant bucket and perform a look up of the string.+3. If it exists, return it.+4. Otherwise grab a unique ID, create a new FastString and atomically attempt+   to update the relevant segment with this FastString:++   * Resize the segment by doubling the number of buckets when the number of+     FastStrings in this segment grows beyond the threshold.+   * Double check that the string is not in the bucket. Another thread may have+     inserted it while we were creating our string.+   * Return the existing FastString if it exists. The one we preemptively+     created will get GCed.+   * Otherwise, insert and return the string we created.+-}++mkFastStringWith+    :: (Int -> IORef Int-> IO FastString) -> Ptr Word8 -> Int -> IO FastString+mkFastStringWith mk_fs !ptr !len = do+  FastStringTableSegment lock _ buckets# <- readIORef segmentRef+  let idx# = hashToIndex# buckets# hash#+  bucket <- IO $ readArray# buckets# idx#+  res <- bucket_match bucket len ptr+  case res of+    Just found -> return found+    Nothing -> do+      -- The withMVar below is not dupable. It can lead to deadlock if it is+      -- only run partially and putMVar is not called after takeMVar.+      noDuplicate+      n <- get_uid+      new_fs <- mk_fs n n_zencs+      withMVar lock $ \_ -> insert new_fs+  where+    !(FastStringTable uid n_zencs segments#) = stringTable+    get_uid = atomicModifyIORef' uid $ \n -> (n+1,n)++    !(I# hash#) = hashStr ptr len+    (# segmentRef #) = indexArray# segments# (hashToSegment# hash#)+    insert fs = do+      FastStringTableSegment _ counter buckets# <- maybeResizeSegment segmentRef+      let idx# = hashToIndex# buckets# hash#+      bucket <- IO $ readArray# buckets# idx#+      res <- bucket_match bucket len ptr+      case res of+        -- The FastString was added by another thread after previous read and+        -- before we acquired the write lock.+        Just found -> return found+        Nothing -> do+          IO $ \s1# ->+            case writeArray# buckets# idx# (fs: bucket) s1# of+              s2# -> (# s2#, () #)+          modifyIORef' counter succ+          return fs++bucket_match :: [FastString] -> Int -> Ptr Word8 -> IO (Maybe FastString)+bucket_match [] _ _ = return Nothing+bucket_match (v@(FastString _ _ bs _):ls) len ptr+      | len == BS.length bs = do+         b <- BS.unsafeUseAsCString bs $ \buf ->+             cmpStringPrefix ptr (castPtr buf) len+         if b then return (Just v)+              else bucket_match ls len ptr+      | otherwise =+         bucket_match ls len ptr++mkFastStringBytes :: Ptr Word8 -> Int -> FastString+mkFastStringBytes !ptr !len =+    -- NB: Might as well use unsafeDupablePerformIO, since mkFastStringWith is+    -- idempotent.+    unsafeDupablePerformIO $+        mkFastStringWith (copyNewFastString ptr len) ptr len++-- | Create a 'FastString' from an existing 'ForeignPtr'; the difference+-- between this and 'mkFastStringBytes' is that we don't have to copy+-- the bytes if the string is new to the table.+mkFastStringForeignPtr :: Ptr Word8 -> ForeignPtr Word8 -> Int -> IO FastString+mkFastStringForeignPtr ptr !fp len+    = mkFastStringWith (mkNewFastString fp ptr len) ptr len++-- | Create a 'FastString' from an existing 'ForeignPtr'; the difference+-- between this and 'mkFastStringBytes' is that we don't have to copy+-- the bytes if the string is new to the table.+mkFastStringByteString :: ByteString -> FastString+mkFastStringByteString bs =+    inlinePerformIO $+      BS.unsafeUseAsCStringLen bs $ \(ptr, len) -> do+        let ptr' = castPtr ptr+        mkFastStringWith (mkNewFastStringByteString bs ptr' len) ptr' len++-- | Creates a UTF-8 encoded 'FastString' from a 'String'+mkFastString :: String -> FastString+mkFastString str =+  inlinePerformIO $ do+    let l = utf8EncodedLength str+    buf <- mallocForeignPtrBytes l+    withForeignPtr buf $ \ptr -> do+      utf8EncodeString ptr str+      mkFastStringForeignPtr ptr buf l++-- | Creates a 'FastString' from a UTF-8 encoded @[Word8]@+mkFastStringByteList :: [Word8] -> FastString+mkFastStringByteList str = mkFastStringByteString (BS.pack str)++-- | Creates a (lazy) Z-encoded 'FastString' from a 'String' and account+-- the number of forced z-strings into the passed 'IORef'.+mkZFastString :: IORef Int -> ByteString -> FastZString+mkZFastString n_zencs bs = unsafePerformIO $ do+  atomicModifyIORef' n_zencs $ \n -> (n+1, ())+  return $ mkFastZStringString (zEncodeString (utf8DecodeByteString bs))++mkNewFastString :: ForeignPtr Word8 -> Ptr Word8 -> Int -> Int+                -> IORef Int -> IO FastString+mkNewFastString fp ptr len uid n_zencs = do+  let bs = BS.fromForeignPtr fp 0 len+      zstr = mkZFastString n_zencs bs+  n_chars <- countUTF8Chars ptr len+  return (FastString uid n_chars bs zstr)++mkNewFastStringByteString :: ByteString -> Ptr Word8 -> Int -> Int+                          -> IORef Int -> IO FastString+mkNewFastStringByteString bs ptr len uid n_zencs = do+  let zstr = mkZFastString n_zencs bs+  n_chars <- countUTF8Chars ptr len+  return (FastString uid n_chars bs zstr)++copyNewFastString :: Ptr Word8 -> Int -> Int -> IORef Int -> IO FastString+copyNewFastString ptr len uid n_zencs = do+  fp <- copyBytesToForeignPtr ptr len+  let bs = BS.fromForeignPtr fp 0 len+      zstr = mkZFastString n_zencs bs+  n_chars <- countUTF8Chars ptr len+  return (FastString uid n_chars bs zstr)++copyBytesToForeignPtr :: Ptr Word8 -> Int -> IO (ForeignPtr Word8)+copyBytesToForeignPtr ptr len = do+  fp <- mallocForeignPtrBytes len+  withForeignPtr fp $ \ptr' -> copyBytes ptr' ptr len+  return fp++cmpStringPrefix :: Ptr Word8 -> Ptr Word8 -> Int -> IO Bool+cmpStringPrefix ptr1 ptr2 len =+ do r <- memcmp ptr1 ptr2 len+    return (r == 0)++hashStr  :: Ptr Word8 -> Int -> Int+ -- use the Addr to produce a hash value between 0 & m (inclusive)+hashStr (Ptr a#) (I# len#) = loop 0# 0#+  where+    loop h n =+      if isTrue# (n ==# len#) then+        I# h+      else+        let+          -- DO NOT move this let binding! indexCharOffAddr# reads from the+          -- pointer so we need to evaluate this based on the length check+          -- above. Not doing this right caused #17909.+          !c = ord# (indexCharOffAddr# a# n)+          !h2 = (h *# 16777619#) `xorI#` c+        in+          loop h2 (n +# 1#)++-- -----------------------------------------------------------------------------+-- Operations++-- | Returns the length of the 'FastString' in characters+lengthFS :: FastString -> Int+lengthFS f = n_chars f++-- | Returns @True@ if the 'FastString' is empty+nullFS :: FastString -> Bool+nullFS f = BS.null (fs_bs f)++-- | Unpacks and decodes the FastString+unpackFS :: FastString -> String+unpackFS (FastString _ _ bs _) = utf8DecodeByteString bs++-- | Returns a Z-encoded version of a 'FastString'.  This might be the+-- original, if it was already Z-encoded.  The first time this+-- function is applied to a particular 'FastString', the results are+-- memoized.+--+zEncodeFS :: FastString -> FastZString+zEncodeFS (FastString _ _ _ ref) = ref++appendFS :: FastString -> FastString -> FastString+appendFS fs1 fs2 = mkFastStringByteString+                 $ BS.append (bytesFS fs1) (bytesFS fs2)++concatFS :: [FastString] -> FastString+concatFS = mkFastStringByteString . BS.concat . map fs_bs++headFS :: FastString -> Char+headFS (FastString _ 0 _ _) = panic "headFS: Empty FastString"+headFS (FastString _ _ bs _) =+  inlinePerformIO $ BS.unsafeUseAsCString bs $ \ptr ->+         return (fst (utf8DecodeChar (castPtr ptr)))++tailFS :: FastString -> FastString+tailFS (FastString _ 0 _ _) = panic "tailFS: Empty FastString"+tailFS (FastString _ _ bs _) =+    inlinePerformIO $ BS.unsafeUseAsCString bs $ \ptr ->+    do let (_, n) = utf8DecodeChar (castPtr ptr)+       return $! mkFastStringByteString (BS.drop n bs)++consFS :: Char -> FastString -> FastString+consFS c fs = mkFastString (c : unpackFS fs)++uniqueOfFS :: FastString -> Int+uniqueOfFS (FastString u _ _ _) = u++nilFS :: FastString+nilFS = mkFastString ""++isUnderscoreFS :: FastString -> Bool+isUnderscoreFS fs = fs == fsLit "_"++-- -----------------------------------------------------------------------------+-- Stats++getFastStringTable :: IO [[[FastString]]]+getFastStringTable =+  forM [0 .. numSegments - 1] $ \(I# i#) -> do+    let (# segmentRef #) = indexArray# segments# i#+    FastStringTableSegment _ _ buckets# <- readIORef segmentRef+    let bucketSize = I# (sizeofMutableArray# buckets#)+    forM [0 .. bucketSize - 1] $ \(I# j#) ->+      IO $ readArray# buckets# j#+  where+    !(FastStringTable _ _ segments#) = stringTable++getFastStringZEncCounter :: IO Int+getFastStringZEncCounter = readIORef n_zencs+  where+    !(FastStringTable _ n_zencs _) = stringTable++-- -----------------------------------------------------------------------------+-- Outputting 'FastString's++-- |Outputs a 'FastString' with /no decoding at all/, that is, you+-- get the actual bytes in the 'FastString' written to the 'Handle'.+hPutFS :: Handle -> FastString -> IO ()+hPutFS handle fs = BS.hPut handle $ bytesFS fs++-- ToDo: we'll probably want an hPutFSLocal, or something, to output+-- in the current locale's encoding (for error messages and suchlike).++-- -----------------------------------------------------------------------------+-- PtrStrings, here for convenience only.++-- | A 'PtrString' is a pointer to some array of Latin-1 encoded chars.+data PtrString = PtrString !(Ptr Word8) !Int++-- | Wrap an unboxed address into a 'PtrString'.+mkPtrString# :: Addr# -> PtrString+mkPtrString# a# = PtrString (Ptr a#) (ptrStrLength (Ptr a#))++-- | Encode a 'String' into a newly allocated 'PtrString' using Latin-1+-- encoding.  The original string must not contain non-Latin-1 characters+-- (above codepoint @0xff@).+{-# INLINE mkPtrString #-}+mkPtrString :: String -> PtrString+mkPtrString s =+ -- we don't use `unsafeDupablePerformIO` here to avoid potential memory leaks+ -- and because someone might be using `eqAddr#` to check for string equality.+ unsafePerformIO (do+   let len = length s+   p <- mallocBytes len+   let+     loop :: Int -> String -> IO ()+     loop !_ []    = return ()+     loop n (c:cs) = do+        pokeByteOff p n (fromIntegral (ord c) :: Word8)+        loop (1+n) cs+   loop 0 s+   return (PtrString p len)+ )++-- | Decode a 'PtrString' back into a 'String' using Latin-1 encoding.+-- This does not free the memory associated with 'PtrString'.+unpackPtrString :: PtrString -> String+unpackPtrString (PtrString (Ptr p#) (I# n#)) = unpackNBytes# p# n#++-- | Return the length of a 'PtrString'+lengthPS :: PtrString -> Int+lengthPS (PtrString _ n) = n++-- -----------------------------------------------------------------------------+-- under the carpet++foreign import ccall unsafe "strlen"+  ptrStrLength :: Ptr Word8 -> Int++{-# NOINLINE sLit #-}+sLit :: String -> PtrString+sLit x  = mkPtrString x++{-# NOINLINE fsLit #-}+fsLit :: String -> FastString+fsLit x = mkFastString x++{-# RULES "slit"+    forall x . sLit  (unpackCString# x) = mkPtrString#  x #-}+{-# RULES "fslit"+    forall x . fsLit (unpackCString# x) = mkFastString# x #-}
+ compiler/GHC/Data/FastString/Env.hs view
@@ -0,0 +1,100 @@+{-+%+% (c) The University of Glasgow 2006+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998+%+-}++-- | FastStringEnv: FastString environments+module GHC.Data.FastString.Env (+        -- * FastString environments (maps)+        FastStringEnv,++        -- ** Manipulating these environments+        mkFsEnv,+        emptyFsEnv, unitFsEnv,+        extendFsEnv_C, extendFsEnv_Acc, extendFsEnv,+        extendFsEnvList, extendFsEnvList_C,+        filterFsEnv,+        plusFsEnv, plusFsEnv_C, alterFsEnv,+        lookupFsEnv, lookupFsEnv_NF, delFromFsEnv, delListFromFsEnv,+        elemFsEnv, mapFsEnv,++        -- * Deterministic FastString environments (maps)+        DFastStringEnv,++        -- ** Manipulating these environments+        mkDFsEnv, emptyDFsEnv, dFsEnvElts, lookupDFsEnv+    ) where++import GHC.Prelude++import GHC.Types.Unique.FM+import GHC.Types.Unique.DFM+import GHC.Data.Maybe+import GHC.Data.FastString+++-- | A non-deterministic set of FastStrings.+-- See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not+-- deterministic and why it matters. Use DFastStringEnv if the set eventually+-- gets converted into a list or folded over in a way where the order+-- changes the generated code.+type FastStringEnv a = UniqFM a  -- Domain is FastString++emptyFsEnv         :: FastStringEnv a+mkFsEnv            :: [(FastString,a)] -> FastStringEnv a+alterFsEnv         :: (Maybe a-> Maybe a) -> FastStringEnv a -> FastString -> FastStringEnv a+extendFsEnv_C      :: (a->a->a) -> FastStringEnv a -> FastString -> a -> FastStringEnv a+extendFsEnv_Acc    :: (a->b->b) -> (a->b) -> FastStringEnv b -> FastString -> a -> FastStringEnv b+extendFsEnv        :: FastStringEnv a -> FastString -> a -> FastStringEnv a+plusFsEnv          :: FastStringEnv a -> FastStringEnv a -> FastStringEnv a+plusFsEnv_C        :: (a->a->a) -> FastStringEnv a -> FastStringEnv a -> FastStringEnv a+extendFsEnvList    :: FastStringEnv a -> [(FastString,a)] -> FastStringEnv a+extendFsEnvList_C  :: (a->a->a) -> FastStringEnv a -> [(FastString,a)] -> FastStringEnv a+delFromFsEnv       :: FastStringEnv a -> FastString -> FastStringEnv a+delListFromFsEnv   :: FastStringEnv a -> [FastString] -> FastStringEnv a+elemFsEnv          :: FastString -> FastStringEnv a -> Bool+unitFsEnv          :: FastString -> a -> FastStringEnv a+lookupFsEnv        :: FastStringEnv a -> FastString -> Maybe a+lookupFsEnv_NF     :: FastStringEnv a -> FastString -> a+filterFsEnv        :: (elt -> Bool) -> FastStringEnv elt -> FastStringEnv elt+mapFsEnv           :: (elt1 -> elt2) -> FastStringEnv elt1 -> FastStringEnv elt2++emptyFsEnv                = emptyUFM+unitFsEnv x y             = unitUFM x y+extendFsEnv x y z         = addToUFM x y z+extendFsEnvList x l       = addListToUFM x l+lookupFsEnv x y           = lookupUFM x y+alterFsEnv                = alterUFM+mkFsEnv     l             = listToUFM l+elemFsEnv x y             = elemUFM x y+plusFsEnv x y             = plusUFM x y+plusFsEnv_C f x y         = plusUFM_C f x y+extendFsEnv_C f x y z     = addToUFM_C f x y z+mapFsEnv f x              = mapUFM f x+extendFsEnv_Acc x y z a b = addToUFM_Acc x y z a b+extendFsEnvList_C x y z   = addListToUFM_C x y z+delFromFsEnv x y          = delFromUFM x y+delListFromFsEnv x y      = delListFromUFM x y+filterFsEnv x y           = filterUFM x y++lookupFsEnv_NF env n = expectJust "lookupFsEnv_NF" (lookupFsEnv env n)++-- Deterministic FastStringEnv+-- See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why we need+-- DFastStringEnv.++type DFastStringEnv a = UniqDFM a  -- Domain is FastString++emptyDFsEnv :: DFastStringEnv a+emptyDFsEnv = emptyUDFM++dFsEnvElts :: DFastStringEnv a -> [a]+dFsEnvElts = eltsUDFM++mkDFsEnv :: [(FastString,a)] -> DFastStringEnv a+mkDFsEnv l = listToUDFM l++lookupDFsEnv :: DFastStringEnv a -> FastString -> Maybe a+lookupDFsEnv = lookupUDFM
+ compiler/GHC/Data/FiniteMap.hs view
@@ -0,0 +1,31 @@+-- Some extra functions to extend Data.Map++module GHC.Data.FiniteMap (+        insertList,+        insertListWith,+        deleteList,+        foldRight, foldRightWithKey+    ) where++import GHC.Prelude++import Data.Map (Map)+import qualified Data.Map as Map++insertList :: Ord key => [(key,elt)] -> Map key elt -> Map key elt+insertList xs m = foldl' (\m (k, v) -> Map.insert k v m) m xs++insertListWith :: Ord key+               => (elt -> elt -> elt)+               -> [(key,elt)]+               -> Map key elt+               -> Map key elt+insertListWith f xs m0 = foldl' (\m (k, v) -> Map.insertWith f k v m) m0 xs++deleteList :: Ord key => [key] -> Map key elt -> Map key elt+deleteList ks m = foldl' (flip Map.delete) m ks++foldRight        :: (elt -> a -> a) -> a -> Map key elt -> a+foldRight        = Map.foldr+foldRightWithKey :: (key -> elt -> a -> a) -> a -> Map key elt -> a+foldRightWithKey = Map.foldrWithKey
+ compiler/GHC/Data/Graph/Directed.hs view
@@ -0,0 +1,524 @@+-- (c) The University of Glasgow 2006++{-# LANGUAGE CPP, ScopedTypeVariables, ViewPatterns #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++module GHC.Data.Graph.Directed (+        Graph, graphFromEdgedVerticesOrd, graphFromEdgedVerticesUniq,++        SCC(..), Node(..), flattenSCC, flattenSCCs,+        stronglyConnCompG,+        topologicalSortG,+        verticesG, edgesG, hasVertexG,+        reachableG, reachablesG, transposeG,+        emptyG,++        findCycle,++        -- For backwards compatibility with the simpler version of Digraph+        stronglyConnCompFromEdgedVerticesOrd,+        stronglyConnCompFromEdgedVerticesOrdR,+        stronglyConnCompFromEdgedVerticesUniq,+        stronglyConnCompFromEdgedVerticesUniqR,++        -- Simple way to classify edges+        EdgeType(..), classifyEdges+    ) where++#include "HsVersions.h"++------------------------------------------------------------------------------+-- A version of the graph algorithms described in:+--+-- ``Lazy Depth-First Search and Linear IntGraph Algorithms in Haskell''+--   by David King and John Launchbury+--+-- Also included is some additional code for printing tree structures ...+--+-- If you ever find yourself in need of algorithms for classifying edges,+-- or finding connected/biconnected components, consult the history; Sigbjorn+-- Finne contributed some implementations in 1997, although we've since+-- removed them since they were not used anywhere in GHC.+------------------------------------------------------------------------------+++import GHC.Prelude++import GHC.Utils.Misc ( minWith, count )+import GHC.Utils.Outputable+import GHC.Data.Maybe ( expectJust )++-- std interfaces+import Data.Maybe+import Data.Array+import Data.List hiding (transpose)+import qualified Data.Map as Map+import qualified Data.Set as Set++import qualified Data.Graph as G+import Data.Graph hiding (Graph, Edge, transposeG, reachable)+import Data.Tree+import GHC.Types.Unique+import GHC.Types.Unique.FM++{-+************************************************************************+*                                                                      *+*      Graphs and Graph Construction+*                                                                      *+************************************************************************++Note [Nodes, keys, vertices]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+ * A 'node' is a big blob of client-stuff++ * Each 'node' has a unique (client) 'key', but the latter+        is in Ord and has fast comparison++ * Digraph then maps each 'key' to a Vertex (Int) which is+        arranged densely in 0.n+-}++data Graph node = Graph {+    gr_int_graph      :: IntGraph,+    gr_vertex_to_node :: Vertex -> node,+    gr_node_to_vertex :: node -> Maybe Vertex+  }++data Edge node = Edge node node++{-| Representation for nodes of the Graph.++ * The @payload@ is user data, just carried around in this module++ * The @key@ is the node identifier.+   Key has an Ord instance for performance reasons.++ * The @[key]@ are the dependencies of the node;+   it's ok to have extra keys in the dependencies that+   are not the key of any Node in the graph+-}+data Node key payload = DigraphNode {+      node_payload :: payload, -- ^ User data+      node_key :: key, -- ^ User defined node id+      node_dependencies :: [key] -- ^ Dependencies/successors of the node+  }+++instance (Outputable a, Outputable b) => Outputable (Node  a b) where+  ppr (DigraphNode a b c) = ppr (a, b, c)++emptyGraph :: Graph a+emptyGraph = Graph (array (1, 0) []) (error "emptyGraph") (const Nothing)++-- See Note [Deterministic SCC]+graphFromEdgedVertices+        :: ReduceFn key payload+        -> [Node key payload]           -- The graph; its ok for the+                                        -- out-list to contain keys which aren't+                                        -- a vertex key, they are ignored+        -> Graph (Node key payload)+graphFromEdgedVertices _reduceFn []            = emptyGraph+graphFromEdgedVertices reduceFn edged_vertices =+  Graph graph vertex_fn (key_vertex . key_extractor)+  where key_extractor = node_key+        (bounds, vertex_fn, key_vertex, numbered_nodes) =+          reduceFn edged_vertices key_extractor+        graph = array bounds [ (v, sort $ mapMaybe key_vertex ks)+                             | (v, (node_dependencies -> ks)) <- numbered_nodes]+                -- We normalize outgoing edges by sorting on node order, so+                -- that the result doesn't depend on the order of the edges++-- See Note [Deterministic SCC]+-- See Note [reduceNodesIntoVertices implementations]+graphFromEdgedVerticesOrd+        :: Ord key+        => [Node key payload]           -- The graph; its ok for the+                                        -- out-list to contain keys which aren't+                                        -- a vertex key, they are ignored+        -> Graph (Node key payload)+graphFromEdgedVerticesOrd = graphFromEdgedVertices reduceNodesIntoVerticesOrd++-- See Note [Deterministic SCC]+-- See Note [reduceNodesIntoVertices implementations]+graphFromEdgedVerticesUniq+        :: Uniquable key+        => [Node key payload]           -- The graph; its ok for the+                                        -- out-list to contain keys which aren't+                                        -- a vertex key, they are ignored+        -> Graph (Node key payload)+graphFromEdgedVerticesUniq = graphFromEdgedVertices reduceNodesIntoVerticesUniq++type ReduceFn key payload =+  [Node key payload] -> (Node key payload -> key) ->+    (Bounds, Vertex -> Node key payload+    , key -> Maybe Vertex, [(Vertex, Node key payload)])++{-+Note [reduceNodesIntoVertices implementations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+reduceNodesIntoVertices is parameterized by the container type.+This is to accommodate key types that don't have an Ord instance+and hence preclude the use of Data.Map. An example of such type+would be Unique, there's no way to implement Ord Unique+deterministically.++For such types, there's a version with a Uniquable constraint.+This leaves us with two versions of every function that depends on+reduceNodesIntoVertices, one with Ord constraint and the other with+Uniquable constraint.+For example: graphFromEdgedVerticesOrd and graphFromEdgedVerticesUniq.++The Uniq version should be a tiny bit more efficient since it uses+Data.IntMap internally.+-}+reduceNodesIntoVertices+  :: ([(key, Vertex)] -> m)+  -> (key -> m -> Maybe Vertex)+  -> ReduceFn key payload+reduceNodesIntoVertices fromList lookup nodes key_extractor =+  (bounds, (!) vertex_map, key_vertex, numbered_nodes)+  where+    max_v           = length nodes - 1+    bounds          = (0, max_v) :: (Vertex, Vertex)++    -- Keep the order intact to make the result depend on input order+    -- instead of key order+    numbered_nodes  = zip [0..] nodes+    vertex_map      = array bounds numbered_nodes++    key_map = fromList+      [ (key_extractor node, v) | (v, node) <- numbered_nodes ]+    key_vertex k = lookup k key_map++-- See Note [reduceNodesIntoVertices implementations]+reduceNodesIntoVerticesOrd :: Ord key => ReduceFn key payload+reduceNodesIntoVerticesOrd = reduceNodesIntoVertices Map.fromList Map.lookup++-- See Note [reduceNodesIntoVertices implementations]+reduceNodesIntoVerticesUniq :: Uniquable key => ReduceFn key payload+reduceNodesIntoVerticesUniq = reduceNodesIntoVertices listToUFM (flip lookupUFM)++{-+************************************************************************+*                                                                      *+*      SCC+*                                                                      *+************************************************************************+-}++type WorkItem key payload+  = (Node key payload,  -- Tip of the path+     [payload])         -- Rest of the path;+                        --  [a,b,c] means c depends on b, b depends on a++-- | Find a reasonably short cycle a->b->c->a, in a strongly+-- connected component.  The input nodes are presumed to be+-- a SCC, so you can start anywhere.+findCycle :: forall payload key. Ord key+          => [Node key payload]     -- The nodes.  The dependencies can+                                    -- contain extra keys, which are ignored+          -> Maybe [payload]        -- A cycle, starting with node+                                    -- so each depends on the next+findCycle graph+  = go Set.empty (new_work root_deps []) []+  where+    env :: Map.Map key (Node key payload)+    env = Map.fromList [ (node_key node, node) | node <- graph ]++    -- Find the node with fewest dependencies among the SCC modules+    -- This is just a heuristic to find some plausible root module+    root :: Node key payload+    root = fst (minWith snd [ (node, count (`Map.member` env)+                                           (node_dependencies node))+                            | node <- graph ])+    DigraphNode root_payload root_key root_deps = root+++    -- 'go' implements Dijkstra's algorithm, more or less+    go :: Set.Set key   -- Visited+       -> [WorkItem key payload]        -- Work list, items length n+       -> [WorkItem key payload]        -- Work list, items length n+1+       -> Maybe [payload]               -- Returned cycle+       -- Invariant: in a call (go visited ps qs),+       --            visited = union (map tail (ps ++ qs))++    go _       [] [] = Nothing  -- No cycles+    go visited [] qs = go visited qs []+    go visited (((DigraphNode payload key deps), path) : ps) qs+       | key == root_key           = Just (root_payload : reverse path)+       | key `Set.member` visited  = go visited ps qs+       | key `Map.notMember` env   = go visited ps qs+       | otherwise                 = go (Set.insert key visited)+                                        ps (new_qs ++ qs)+       where+         new_qs = new_work deps (payload : path)++    new_work :: [key] -> [payload] -> [WorkItem key payload]+    new_work deps path = [ (n, path) | Just n <- map (`Map.lookup` env) deps ]++{-+************************************************************************+*                                                                      *+*      Strongly Connected Component wrappers for Graph+*                                                                      *+************************************************************************++Note: the components are returned topologically sorted: later components+depend on earlier ones, but not vice versa i.e. later components only have+edges going from them to earlier ones.+-}++{-+Note [Deterministic SCC]+~~~~~~~~~~~~~~~~~~~~~~~~+stronglyConnCompFromEdgedVerticesUniq,+stronglyConnCompFromEdgedVerticesUniqR,+stronglyConnCompFromEdgedVerticesOrd and+stronglyConnCompFromEdgedVerticesOrdR+provide a following guarantee:+Given a deterministically ordered list of nodes it returns a deterministically+ordered list of strongly connected components, where the list of vertices+in an SCC is also deterministically ordered.+Note that the order of edges doesn't need to be deterministic for this to work.+We use the order of nodes to normalize the order of edges.+-}++stronglyConnCompG :: Graph node -> [SCC node]+stronglyConnCompG graph = decodeSccs graph forest+  where forest = {-# SCC "Digraph.scc" #-} scc (gr_int_graph graph)++decodeSccs :: Graph node -> Forest Vertex -> [SCC node]+decodeSccs Graph { gr_int_graph = graph, gr_vertex_to_node = vertex_fn } forest+  = map decode forest+  where+    decode (Node v []) | mentions_itself v = CyclicSCC [vertex_fn v]+                       | otherwise         = AcyclicSCC (vertex_fn v)+    decode other = CyclicSCC (dec other [])+      where dec (Node v ts) vs = vertex_fn v : foldr dec vs ts+    mentions_itself v = v `elem` (graph ! v)+++-- The following two versions are provided for backwards compatibility:+-- See Note [Deterministic SCC]+-- See Note [reduceNodesIntoVertices implementations]+stronglyConnCompFromEdgedVerticesOrd+        :: Ord key+        => [Node key payload]+        -> [SCC payload]+stronglyConnCompFromEdgedVerticesOrd+  = map (fmap node_payload) . stronglyConnCompFromEdgedVerticesOrdR++-- The following two versions are provided for backwards compatibility:+-- See Note [Deterministic SCC]+-- See Note [reduceNodesIntoVertices implementations]+stronglyConnCompFromEdgedVerticesUniq+        :: Uniquable key+        => [Node key payload]+        -> [SCC payload]+stronglyConnCompFromEdgedVerticesUniq+  = map (fmap node_payload) . stronglyConnCompFromEdgedVerticesUniqR++-- The "R" interface is used when you expect to apply SCC to+-- (some of) the result of SCC, so you don't want to lose the dependency info+-- See Note [Deterministic SCC]+-- See Note [reduceNodesIntoVertices implementations]+stronglyConnCompFromEdgedVerticesOrdR+        :: Ord key+        => [Node key payload]+        -> [SCC (Node key payload)]+stronglyConnCompFromEdgedVerticesOrdR =+  stronglyConnCompG . graphFromEdgedVertices reduceNodesIntoVerticesOrd++-- The "R" interface is used when you expect to apply SCC to+-- (some of) the result of SCC, so you don't want to lose the dependency info+-- See Note [Deterministic SCC]+-- See Note [reduceNodesIntoVertices implementations]+stronglyConnCompFromEdgedVerticesUniqR+        :: Uniquable key+        => [Node key payload]+        -> [SCC (Node key payload)]+stronglyConnCompFromEdgedVerticesUniqR =+  stronglyConnCompG . graphFromEdgedVertices reduceNodesIntoVerticesUniq++{-+************************************************************************+*                                                                      *+*      Misc wrappers for Graph+*                                                                      *+************************************************************************+-}++topologicalSortG :: Graph node -> [node]+topologicalSortG graph = map (gr_vertex_to_node graph) result+  where result = {-# SCC "Digraph.topSort" #-} topSort (gr_int_graph graph)++reachableG :: Graph node -> node -> [node]+reachableG graph from = map (gr_vertex_to_node graph) result+  where from_vertex = expectJust "reachableG" (gr_node_to_vertex graph from)+        result = {-# SCC "Digraph.reachable" #-} reachable (gr_int_graph graph) [from_vertex]++-- | Given a list of roots return all reachable nodes.+reachablesG :: Graph node -> [node] -> [node]+reachablesG graph froms = map (gr_vertex_to_node graph) result+  where result = {-# SCC "Digraph.reachable" #-}+                 reachable (gr_int_graph graph) vs+        vs = [ v | Just v <- map (gr_node_to_vertex graph) froms ]++hasVertexG :: Graph node -> node -> Bool+hasVertexG graph node = isJust $ gr_node_to_vertex graph node++verticesG :: Graph node -> [node]+verticesG graph = map (gr_vertex_to_node graph) $ vertices (gr_int_graph graph)++edgesG :: Graph node -> [Edge node]+edgesG graph = map (\(v1, v2) -> Edge (v2n v1) (v2n v2)) $ edges (gr_int_graph graph)+  where v2n = gr_vertex_to_node graph++transposeG :: Graph node -> Graph node+transposeG graph = Graph (G.transposeG (gr_int_graph graph))+                         (gr_vertex_to_node graph)+                         (gr_node_to_vertex graph)++emptyG :: Graph node -> Bool+emptyG g = graphEmpty (gr_int_graph g)++{-+************************************************************************+*                                                                      *+*      Showing Graphs+*                                                                      *+************************************************************************+-}++instance Outputable node => Outputable (Graph node) where+    ppr graph = vcat [+                  hang (text "Vertices:") 2 (vcat (map ppr $ verticesG graph)),+                  hang (text "Edges:") 2 (vcat (map ppr $ edgesG graph))+                ]++instance Outputable node => Outputable (Edge node) where+    ppr (Edge from to) = ppr from <+> text "->" <+> ppr to++graphEmpty :: G.Graph -> Bool+graphEmpty g = lo > hi+  where (lo, hi) = bounds g++{-+************************************************************************+*                                                                      *+*      IntGraphs+*                                                                      *+************************************************************************+-}++type IntGraph = G.Graph++{-+------------------------------------------------------------+-- Depth first search numbering+------------------------------------------------------------+-}++-- Data.Tree has flatten for Tree, but nothing for Forest+preorderF           :: Forest a -> [a]+preorderF ts         = concatMap flatten ts++{-+------------------------------------------------------------+-- Finding reachable vertices+------------------------------------------------------------+-}++-- This generalizes reachable which was found in Data.Graph+reachable    :: IntGraph -> [Vertex] -> [Vertex]+reachable g vs = preorderF (dfs g vs)++{-+************************************************************************+*                                                                      *+*                         Classify Edge Types+*                                                                      *+************************************************************************+-}++-- Remark: While we could generalize this algorithm this comes at a runtime+-- cost and with no advantages. If you find yourself using this with graphs+-- not easily represented using Int nodes please consider rewriting this+-- using the more general Graph type.++-- | Edge direction based on DFS Classification+data EdgeType+  = Forward+  | Cross+  | Backward -- ^ Loop back towards the root node.+             -- Eg backjumps in loops+  | SelfLoop -- ^ v -> v+   deriving (Eq,Ord)++instance Outputable EdgeType where+  ppr Forward = text "Forward"+  ppr Cross = text "Cross"+  ppr Backward = text "Backward"+  ppr SelfLoop = text "SelfLoop"++newtype Time = Time Int deriving (Eq,Ord,Num,Outputable)++--Allow for specialization+{-# INLINEABLE classifyEdges #-}++-- | Given a start vertex, a way to get successors from a node+-- and a list of (directed) edges classify the types of edges.+classifyEdges :: forall key. Uniquable key => key -> (key -> [key])+              -> [(key,key)] -> [((key, key), EdgeType)]+classifyEdges root getSucc edges =+    --let uqe (from,to) = (getUnique from, getUnique to)+    --in pprTrace "Edges:" (ppr $ map uqe edges) $+    zip edges $ map classify edges+  where+    (_time, starts, ends) = addTimes (0,emptyUFM,emptyUFM) root+    classify :: (key,key) -> EdgeType+    classify (from,to)+      | startFrom < startTo+      , endFrom   > endTo+      = Forward+      | startFrom > startTo+      , endFrom   < endTo+      = Backward+      | startFrom > startTo+      , endFrom   > endTo+      = Cross+      | getUnique from == getUnique to+      = SelfLoop+      | otherwise+      = pprPanic "Failed to classify edge of Graph"+                 (ppr (getUnique from, getUnique to))++      where+        getTime event node+          | Just time <- lookupUFM event node+          = time+          | otherwise+          = pprPanic "Failed to classify edge of CFG - not not timed"+            (text "edges" <> ppr (getUnique from, getUnique to)+                          <+> ppr starts <+> ppr ends )+        startFrom = getTime starts from+        startTo   = getTime starts to+        endFrom   = getTime ends   from+        endTo     = getTime ends   to++    addTimes :: (Time, UniqFM Time, UniqFM Time) -> key+             -> (Time, UniqFM Time, UniqFM Time)+    addTimes (time,starts,ends) n+      --Dont reenter nodes+      | elemUFM n starts+      = (time,starts,ends)+      | otherwise =+        let+          starts' = addToUFM starts n time+          time' = time + 1+          succs = getSucc n :: [key]+          (time'',starts'',ends') = foldl' addTimes (time',starts',ends) succs+          ends'' = addToUFM ends' n time''+        in+        (time'' + 1, starts'', ends'')
+ compiler/GHC/Data/IOEnv.hs view
@@ -0,0 +1,219 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveFunctor #-}+--+-- (c) The University of Glasgow 2002-2006+--++-- | The IO Monad with an environment+--+-- The environment is passed around as a Reader monad but+-- as its in the IO monad, mutable references can be used+-- for updating state.+--+module GHC.Data.IOEnv (+        IOEnv, -- Instance of Monad++        -- Monad utilities+        module GHC.Utils.Monad,++        -- Errors+        failM, failWithM,+        IOEnvFailure(..),++        -- Getting at the environment+        getEnv, setEnv, updEnv,++        runIOEnv, unsafeInterleaveM, uninterruptibleMaskM_,+        tryM, tryAllM, tryMostM, fixM,++        -- I/O operations+        IORef, newMutVar, readMutVar, writeMutVar, updMutVar,+        atomicUpdMutVar, atomicUpdMutVar'+  ) where++import GHC.Prelude++import GHC.Driver.Session+import GHC.Utils.Exception+import GHC.Unit.Module+import GHC.Utils.Panic++import Data.IORef       ( IORef, newIORef, readIORef, writeIORef, modifyIORef,+                          atomicModifyIORef, atomicModifyIORef' )+import System.IO.Unsafe ( unsafeInterleaveIO )+import System.IO        ( fixIO )+import Control.Monad+import GHC.Utils.Monad+import Control.Applicative (Alternative(..))++----------------------------------------------------------------------+-- Defining the monad type+----------------------------------------------------------------------+++newtype IOEnv env a = IOEnv (env -> IO a) deriving (Functor)++unIOEnv :: IOEnv env a -> (env -> IO a)+unIOEnv (IOEnv m) = m++instance Monad (IOEnv m) where+    (>>=)  = thenM+    (>>)   = (*>)++instance MonadFail (IOEnv m) where+    fail _ = failM -- Ignore the string++instance Applicative (IOEnv m) where+    pure = returnM+    IOEnv f <*> IOEnv x = IOEnv (\ env -> f env <*> x env )+    (*>) = thenM_++returnM :: a -> IOEnv env a+returnM a = IOEnv (\ _ -> return a)++thenM :: IOEnv env a -> (a -> IOEnv env b) -> IOEnv env b+thenM (IOEnv m) f = IOEnv (\ env -> do { r <- m env ;+                                         unIOEnv (f r) env })++thenM_ :: IOEnv env a -> IOEnv env b -> IOEnv env b+thenM_ (IOEnv m) f = IOEnv (\ env -> do { _ <- m env ; unIOEnv f env })++failM :: IOEnv env a+failM = IOEnv (\ _ -> throwIO IOEnvFailure)++failWithM :: String -> IOEnv env a+failWithM s = IOEnv (\ _ -> ioError (userError s))++data IOEnvFailure = IOEnvFailure++instance Show IOEnvFailure where+    show IOEnvFailure = "IOEnv failure"++instance Exception IOEnvFailure++instance ExceptionMonad (IOEnv a) where+  gcatch act handle =+      IOEnv $ \s -> unIOEnv act s `gcatch` \e -> unIOEnv (handle e) s+  gmask f =+      IOEnv $ \s -> gmask $ \io_restore ->+                             let+                                g_restore (IOEnv m) = IOEnv $ \s -> io_restore (m s)+                             in+                                unIOEnv (f g_restore) s++instance ContainsDynFlags env => HasDynFlags (IOEnv env) where+    getDynFlags = do env <- getEnv+                     return $! extractDynFlags env++instance ContainsModule env => HasModule (IOEnv env) where+    getModule = do env <- getEnv+                   return $ extractModule env++----------------------------------------------------------------------+-- Fundamental combinators specific to the monad+----------------------------------------------------------------------+++---------------------------+runIOEnv :: env -> IOEnv env a -> IO a+runIOEnv env (IOEnv m) = m env+++---------------------------+{-# NOINLINE fixM #-}+  -- Aargh!  Not inlining fixM alleviates a space leak problem.+  -- Normally fixM is used with a lazy tuple match: if the optimiser is+  -- shown the definition of fixM, it occasionally transforms the code+  -- in such a way that the code generator doesn't spot the selector+  -- thunks.  Sigh.++fixM :: (a -> IOEnv env a) -> IOEnv env a+fixM f = IOEnv (\ env -> fixIO (\ r -> unIOEnv (f r) env))+++---------------------------+tryM :: IOEnv env r -> IOEnv env (Either IOEnvFailure r)+-- Reflect UserError exceptions (only) into IOEnv monad+-- Other exceptions are not caught; they are simply propagated as exns+--+-- The idea is that errors in the program being compiled will give rise+-- to UserErrors.  But, say, pattern-match failures in GHC itself should+-- not be caught here, else they'll be reported as errors in the program+-- begin compiled!+tryM (IOEnv thing) = IOEnv (\ env -> tryIOEnvFailure (thing env))++tryIOEnvFailure :: IO a -> IO (Either IOEnvFailure a)+tryIOEnvFailure = try++-- XXX We shouldn't be catching everything, e.g. timeouts+tryAllM :: IOEnv env r -> IOEnv env (Either SomeException r)+-- Catch *all* exceptions+-- This is used when running a Template-Haskell splice, when+-- even a pattern-match failure is a programmer error+tryAllM (IOEnv thing) = IOEnv (\ env -> try (thing env))++tryMostM :: IOEnv env r -> IOEnv env (Either SomeException r)+tryMostM (IOEnv thing) = IOEnv (\ env -> tryMost (thing env))++---------------------------+unsafeInterleaveM :: IOEnv env a -> IOEnv env a+unsafeInterleaveM (IOEnv m) = IOEnv (\ env -> unsafeInterleaveIO (m env))++uninterruptibleMaskM_ :: IOEnv env a -> IOEnv env a+uninterruptibleMaskM_ (IOEnv m) = IOEnv (\ env -> uninterruptibleMask_ (m env))++----------------------------------------------------------------------+-- Alternative/MonadPlus+----------------------------------------------------------------------++instance Alternative (IOEnv env) where+    empty   = IOEnv (const empty)+    m <|> n = IOEnv (\env -> unIOEnv m env <|> unIOEnv n env)++instance MonadPlus (IOEnv env)++----------------------------------------------------------------------+-- Accessing input/output+----------------------------------------------------------------------++instance MonadIO (IOEnv env) where+    liftIO io = IOEnv (\ _ -> io)++newMutVar :: a -> IOEnv env (IORef a)+newMutVar val = liftIO (newIORef val)++writeMutVar :: IORef a -> a -> IOEnv env ()+writeMutVar var val = liftIO (writeIORef var val)++readMutVar :: IORef a -> IOEnv env a+readMutVar var = liftIO (readIORef var)++updMutVar :: IORef a -> (a -> a) -> IOEnv env ()+updMutVar var upd = liftIO (modifyIORef var upd)++-- | Atomically update the reference.  Does not force the evaluation of the+-- new variable contents.  For strict update, use 'atomicUpdMutVar''.+atomicUpdMutVar :: IORef a -> (a -> (a, b)) -> IOEnv env b+atomicUpdMutVar var upd = liftIO (atomicModifyIORef var upd)++-- | Strict variant of 'atomicUpdMutVar'.+atomicUpdMutVar' :: IORef a -> (a -> (a, b)) -> IOEnv env b+atomicUpdMutVar' var upd = liftIO (atomicModifyIORef' var upd)++----------------------------------------------------------------------+-- Accessing the environment+----------------------------------------------------------------------++getEnv :: IOEnv env env+{-# INLINE getEnv #-}+getEnv = IOEnv (\ env -> return env)++-- | Perform a computation with a different environment+setEnv :: env' -> IOEnv env' a -> IOEnv env a+{-# INLINE setEnv #-}+setEnv new_env (IOEnv m) = IOEnv (\ _ -> m new_env)++-- | Perform a computation with an altered environment+updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a+{-# INLINE updEnv #-}+updEnv upd (IOEnv m) = IOEnv (\ env -> m (upd env))
+ compiler/GHC/Data/List/SetOps.hs view
@@ -0,0 +1,182 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++-}++{-# LANGUAGE CPP #-}++-- | Set-like operations on lists+--+-- Avoid using them as much as possible+module GHC.Data.List.SetOps (+        unionLists, minusList, deleteBys,++        -- Association lists+        Assoc, assoc, assocMaybe, assocUsing, assocDefault, assocDefaultUsing,++        -- Duplicate handling+        hasNoDups, removeDups, findDupsEq,+        equivClasses,++        -- Indexing+        getNth+   ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Utils.Outputable+import GHC.Utils.Misc++import qualified Data.List as L+import qualified Data.List.NonEmpty as NE+import Data.List.NonEmpty (NonEmpty(..))+import qualified Data.Set as S++getNth :: Outputable a => [a] -> Int -> a+getNth xs n = ASSERT2( xs `lengthExceeds` n, ppr n $$ ppr xs )+             xs !! n++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 (L.deleteBy eq)) xs ys++{-+************************************************************************+*                                                                      *+        Treating lists as sets+        Assumes the lists contain no duplicates, but are unordered+*                                                                      *+************************************************************************+-}+++-- | Assumes that the arguments contain no duplicates+unionLists :: (HasDebugCallStack, Outputable a, Eq a) => [a] -> [a] -> [a]+-- We special case some reasonable common patterns.+unionLists xs [] = xs+unionLists [] ys = ys+unionLists [x] ys+  | isIn "unionLists" x ys = ys+  | otherwise = x:ys+unionLists xs [y]+  | isIn "unionLists" y xs = xs+  | otherwise = y:xs+unionLists xs ys+  = WARN(lengthExceeds xs 100 || lengthExceeds ys 100, ppr xs $$ ppr ys)+    [x | x <- xs, isn'tIn "unionLists" x ys] ++ ys++-- | Calculate the set difference of two lists. This is+-- /O((m + n) log n)/, where we subtract a list of /n/ elements+-- from a list of /m/ elements.+--+-- Extremely short cases are handled specially:+-- When /m/ or /n/ is 0, this takes /O(1)/ time. When /m/ is 1,+-- it takes /O(n)/ time.+minusList :: Ord a => [a] -> [a] -> [a]+-- There's no point building a set to perform just one lookup, so we handle+-- extremely short lists specially. It might actually be better to use+-- an O(m*n) algorithm when m is a little longer (perhaps up to 4 or even 5).+-- The tipping point will be somewhere in the area of where /m/ and /log n/+-- become comparable, but we probably don't want to work too hard on this.+minusList [] _ = []+minusList xs@[x] ys+  | x `elem` ys = []+  | otherwise = xs+-- Using an empty set or a singleton would also be silly, so let's not.+minusList xs [] = xs+minusList xs [y] = filter (/= y) xs+-- When each list has at least two elements, we build a set from the+-- second argument, allowing us to filter the first argument fairly+-- efficiently.+minusList xs ys = filter (`S.notMember` yss) xs+  where+    yss = S.fromList ys++{-+************************************************************************+*                                                                      *+\subsection[Utils-assoc]{Association lists}+*                                                                      *+************************************************************************++Inefficient finite maps based on association lists and equality.+-}++-- A finite mapping based on equality and association lists+type Assoc a b = [(a,b)]++assoc             :: (Eq a) => String -> Assoc a b -> a -> b+assocDefault      :: (Eq a) => b -> Assoc a b -> a -> b+assocUsing        :: (a -> a -> Bool) -> String -> Assoc a b -> a -> b+assocMaybe        :: (Eq a) => Assoc a b -> a -> Maybe b+assocDefaultUsing :: (a -> a -> Bool) -> b -> Assoc a b -> a -> b++assocDefaultUsing _  deflt []             _   = deflt+assocDefaultUsing eq deflt ((k,v) : rest) key+  | k `eq` key = v+  | otherwise  = assocDefaultUsing eq deflt rest key++assoc crash_msg         list key = assocDefaultUsing (==) (panic ("Failed in assoc: " ++ crash_msg)) list key+assocDefault deflt      list key = assocDefaultUsing (==) deflt list key+assocUsing eq crash_msg list key = assocDefaultUsing eq (panic ("Failed in assoc: " ++ crash_msg)) list key++assocMaybe alist key+  = lookup alist+  where+    lookup []             = Nothing+    lookup ((tv,ty):rest) = if key == tv then Just ty else lookup rest++{-+************************************************************************+*                                                                      *+\subsection[Utils-dups]{Duplicate-handling}+*                                                                      *+************************************************************************+-}++hasNoDups :: (Eq a) => [a] -> Bool++hasNoDups xs = f [] xs+  where+    f _           []     = True+    f seen_so_far (x:xs) = if x `is_elem` seen_so_far+                           then False+                           else f (x:seen_so_far) xs++    is_elem = isIn "hasNoDups"++equivClasses :: (a -> a -> Ordering) -- Comparison+             -> [a]+             -> [NonEmpty a]++equivClasses _   []      = []+equivClasses _   [stuff] = [stuff :| []]+equivClasses cmp items   = NE.groupBy eq (L.sortBy cmp items)+  where+    eq a b = case cmp a b of { EQ -> True; _ -> False }++removeDups :: (a -> a -> Ordering) -- Comparison function+           -> [a]+           -> ([a],          -- List with no duplicates+               [NonEmpty a]) -- List of duplicate groups.  One representative+                             -- from each group appears in the first result++removeDups _   []  = ([], [])+removeDups _   [x] = ([x],[])+removeDups cmp xs+  = case L.mapAccumR collect_dups [] (equivClasses cmp xs) of { (dups, xs') ->+    (xs', dups) }+  where+    collect_dups :: [NonEmpty a] -> NonEmpty a -> ([NonEmpty a], a)+    collect_dups dups_so_far (x :| [])     = (dups_so_far,      x)+    collect_dups dups_so_far dups@(x :| _) = (dups:dups_so_far, x)++findDupsEq :: (a->a->Bool) -> [a] -> [NonEmpty a]+findDupsEq _  [] = []+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/GHC/Data/Maybe.hs view
@@ -0,0 +1,114 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE FlexibleContexts #-}++{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+-}++module GHC.Data.Maybe (+        module Data.Maybe,++        MaybeErr(..), -- Instance of Monad+        failME, isSuccess,++        orElse,+        firstJust, firstJusts,+        whenIsJust,+        expectJust,+        rightToMaybe,++        -- * MaybeT+        MaybeT(..), liftMaybeT, tryMaybeT+    ) where++import GHC.Prelude++import Control.Monad+import Control.Monad.Trans.Maybe+import Control.Exception (catch, SomeException(..))+import Data.Maybe+import GHC.Utils.Misc (HasCallStack)++infixr 4 `orElse`++{-+************************************************************************+*                                                                      *+\subsection[Maybe type]{The @Maybe@ type}+*                                                                      *+************************************************************************+-}++firstJust :: Maybe a -> Maybe a -> Maybe a+firstJust a b = firstJusts [a, b]++-- | Takes a list of @Maybes@ and returns the first @Just@ if there is one, or+-- @Nothing@ otherwise.+firstJusts :: [Maybe a] -> Maybe a+firstJusts = msum++expectJust :: HasCallStack => String -> Maybe a -> a+{-# INLINE expectJust #-}+expectJust _   (Just x) = x+expectJust err Nothing  = error ("expectJust " ++ err)++whenIsJust :: Monad m => Maybe a -> (a -> m ()) -> m ()+whenIsJust (Just x) f = f x+whenIsJust Nothing  _ = return ()++-- | Flipped version of @fromMaybe@, useful for chaining.+orElse :: Maybe a -> a -> a+orElse = flip fromMaybe++rightToMaybe :: Either a b -> Maybe b+rightToMaybe (Left _)  = Nothing+rightToMaybe (Right x) = Just x++{-+************************************************************************+*                                                                      *+\subsection[MaybeT type]{The @MaybeT@ monad transformer}+*                                                                      *+************************************************************************+-}++-- We had our own MaybeT in the past. Now we reuse transformer's MaybeT++liftMaybeT :: Monad m => m a -> MaybeT m a+liftMaybeT act = MaybeT $ Just `liftM` act++-- | Try performing an 'IO' action, failing on error.+tryMaybeT :: IO a -> MaybeT IO a+tryMaybeT action = MaybeT $ catch (Just `fmap` action) handler+  where+    handler (SomeException _) = return Nothing++{-+************************************************************************+*                                                                      *+\subsection[MaybeErr type]{The @MaybeErr@ type}+*                                                                      *+************************************************************************+-}++data MaybeErr err val = Succeeded val | Failed err+    deriving (Functor)++instance Applicative (MaybeErr err) where+  pure  = Succeeded+  (<*>) = ap++instance Monad (MaybeErr err) where+  Succeeded v >>= k = k v+  Failed e    >>= _ = Failed e++isSuccess :: MaybeErr err val -> Bool+isSuccess (Succeeded {}) = True+isSuccess (Failed {})    = False++failME :: err -> MaybeErr err val+failME e = Failed e
+ compiler/GHC/Data/OrdList.hs view
@@ -0,0 +1,192 @@+{-+(c) The University of Glasgow 2006+(c) The AQUA Project, Glasgow University, 1993-1998+++-}+{-# LANGUAGE DeriveFunctor #-}++{-# LANGUAGE BangPatterns #-}++-- | Provide trees (of instructions), so that lists of instructions can be+-- appended in linear time.+module GHC.Data.OrdList (+        OrdList,+        nilOL, isNilOL, unitOL, appOL, consOL, snocOL, concatOL, lastOL,+        headOL,+        mapOL, fromOL, toOL, foldrOL, foldlOL, reverseOL, fromOLReverse,+        strictlyEqOL, strictlyOrdOL+) where++import GHC.Prelude+import Data.Foldable++import GHC.Utils.Outputable++import qualified Data.Semigroup as Semigroup++infixl 5  `appOL`+infixl 5  `snocOL`+infixr 5  `consOL`++data OrdList a+  = None+  | One a+  | Many [a]          -- Invariant: non-empty+  | Cons a (OrdList a)+  | Snoc (OrdList a) a+  | Two (OrdList a) -- Invariant: non-empty+        (OrdList a) -- Invariant: non-empty+  deriving (Functor)++instance Outputable a => Outputable (OrdList a) where+  ppr ol = ppr (fromOL ol)  -- Convert to list and print that++instance Semigroup (OrdList a) where+  (<>) = appOL++instance Monoid (OrdList a) where+  mempty = nilOL+  mappend = (Semigroup.<>)+  mconcat = concatOL++instance Foldable OrdList where+  foldr   = foldrOL+  foldl'  = foldlOL+  toList  = fromOL+  null    = isNilOL+  length  = lengthOL++instance Traversable OrdList where+  traverse f xs = toOL <$> traverse f (fromOL xs)++nilOL    :: OrdList a+isNilOL  :: OrdList a -> Bool++unitOL   :: a           -> OrdList a+snocOL   :: OrdList a   -> a         -> OrdList a+consOL   :: a           -> OrdList a -> OrdList a+appOL    :: OrdList a   -> OrdList a -> OrdList a+concatOL :: [OrdList a] -> OrdList a+headOL   :: OrdList a   -> a+lastOL   :: OrdList a   -> a+lengthOL :: OrdList a   -> Int++nilOL        = None+unitOL as    = One as+snocOL as   b    = Snoc as b+consOL a    bs   = Cons a bs+concatOL aas = foldr appOL None aas++headOL None        = panic "headOL"+headOL (One a)     = a+headOL (Many as)   = head as+headOL (Cons a _)  = a+headOL (Snoc as _) = headOL as+headOL (Two as _)  = headOL as++lastOL None        = panic "lastOL"+lastOL (One a)     = a+lastOL (Many as)   = last as+lastOL (Cons _ as) = lastOL as+lastOL (Snoc _ a)  = a+lastOL (Two _ as)  = lastOL as++lengthOL None        = 0+lengthOL (One _)     = 1+lengthOL (Many as)   = length as+lengthOL (Cons _ as) = 1 + length as+lengthOL (Snoc as _) = 1 + length as+lengthOL (Two as bs) = length as + length bs++isNilOL None = True+isNilOL _    = False++None  `appOL` b     = b+a     `appOL` None  = a+One a `appOL` b     = Cons a b+a     `appOL` One b = Snoc a b+a     `appOL` b     = Two a b++fromOL :: OrdList a -> [a]+fromOL a = go a []+  where go None       acc = acc+        go (One a)    acc = a : acc+        go (Cons a b) acc = a : go b acc+        go (Snoc a b) acc = go a (b:acc)+        go (Two a b)  acc = go a (go b acc)+        go (Many xs)  acc = xs ++ acc++fromOLReverse :: OrdList a -> [a]+fromOLReverse a = go a []+        -- acc is already in reverse order+  where go :: OrdList a -> [a] -> [a]+        go None       acc = acc+        go (One a)    acc = a : acc+        go (Cons a b) acc = go b (a : acc)+        go (Snoc a b) acc = b : go a acc+        go (Two a b)  acc = go b (go a acc)+        go (Many xs)  acc = reverse xs ++ acc++mapOL :: (a -> b) -> OrdList a -> OrdList b+mapOL = fmap++foldrOL :: (a->b->b) -> b -> OrdList a -> b+foldrOL _ z None        = z+foldrOL k z (One x)     = k x z+foldrOL k z (Cons x xs) = k x (foldrOL k z xs)+foldrOL k z (Snoc xs x) = foldrOL k (k x z) xs+foldrOL k z (Two b1 b2) = foldrOL k (foldrOL k z b2) b1+foldrOL k z (Many xs)   = foldr k z xs++-- | Strict left fold.+foldlOL :: (b->a->b) -> b -> OrdList a -> b+foldlOL _ z None        = z+foldlOL k z (One x)     = k z x+foldlOL k z (Cons x xs) = let !z' = (k z x) in foldlOL k z' xs+foldlOL k z (Snoc xs x) = let !z' = (foldlOL k z xs) in k z' x+foldlOL k z (Two b1 b2) = let !z' = (foldlOL k z b1) in foldlOL k z' b2+foldlOL k z (Many xs)   = foldl' k z xs++toOL :: [a] -> OrdList a+toOL [] = None+toOL [x] = One x+toOL xs = Many xs++reverseOL :: OrdList a -> OrdList a+reverseOL None = None+reverseOL (One x) = One x+reverseOL (Cons a b) = Snoc (reverseOL b) a+reverseOL (Snoc a b) = Cons b (reverseOL a)+reverseOL (Two a b)  = Two (reverseOL b) (reverseOL a)+reverseOL (Many xs)  = Many (reverse xs)++-- | Compare not only the values but also the structure of two lists+strictlyEqOL :: Eq a => OrdList a   -> OrdList a -> Bool+strictlyEqOL None         None       = True+strictlyEqOL (One x)     (One y)     = x == y+strictlyEqOL (Cons a as) (Cons b bs) = a == b && as `strictlyEqOL` bs+strictlyEqOL (Snoc as a) (Snoc bs b) = a == b && as `strictlyEqOL` bs+strictlyEqOL (Two a1 a2) (Two b1 b2) = a1 `strictlyEqOL` b1 && a2 `strictlyEqOL` b2+strictlyEqOL (Many as)   (Many bs)   = as == bs+strictlyEqOL _            _          = False++-- | Compare not only the values but also the structure of two lists+strictlyOrdOL :: Ord a => OrdList a   -> OrdList a -> Ordering+strictlyOrdOL None         None       = EQ+strictlyOrdOL None         _          = LT+strictlyOrdOL (One x)     (One y)     = compare x y+strictlyOrdOL (One _)      _          = LT+strictlyOrdOL (Cons a as) (Cons b bs) =+  compare a b `mappend` strictlyOrdOL as bs+strictlyOrdOL (Cons _ _)   _          = LT+strictlyOrdOL (Snoc as a) (Snoc bs b) =+  compare a b `mappend` strictlyOrdOL as bs+strictlyOrdOL (Snoc _ _)   _          = LT+strictlyOrdOL (Two a1 a2) (Two b1 b2) =+  (strictlyOrdOL a1 b1) `mappend` (strictlyOrdOL a2 b2)+strictlyOrdOL (Two _ _)    _          = LT+strictlyOrdOL (Many as)   (Many bs)   = compare as bs+strictlyOrdOL (Many _ )   _           = GT++
+ compiler/GHC/Data/Pair.hs view
@@ -0,0 +1,68 @@+{-+A simple homogeneous pair type with useful Functor, Applicative, and+Traversable instances.+-}++{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveFunctor #-}++module GHC.Data.Pair+   ( Pair(..)+   , unPair+   , toPair+   , swap+   , pLiftFst+   , pLiftSnd+   )+where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Utils.Outputable+import qualified Data.Semigroup as Semi++data Pair a = Pair { pFst :: a, pSnd :: a }+  deriving (Functor)+-- Note that Pair is a *unary* type constructor+-- whereas (,) is binary++-- The important thing about Pair is that it has a *homogeneous*+-- Functor instance, so you can easily apply the same function+-- to both components++instance Applicative Pair where+  pure x = Pair x x+  (Pair f g) <*> (Pair x y) = Pair (f x) (g y)++instance Foldable Pair where+  foldMap f (Pair x y) = f x `mappend` f y++instance Traversable Pair where+  traverse f (Pair x y) = Pair <$> f x <*> f y++instance Semi.Semigroup a => Semi.Semigroup (Pair a) where+  Pair a1 b1 <> Pair a2 b2 =  Pair (a1 Semi.<> a2) (b1 Semi.<> b2)++instance (Semi.Semigroup a, Monoid a) => Monoid (Pair a) where+  mempty = Pair mempty mempty+  mappend = (Semi.<>)++instance Outputable a => Outputable (Pair a) where+  ppr (Pair a b) = ppr a <+> char '~' <+> ppr b++unPair :: Pair a -> (a,a)+unPair (Pair x y) = (x,y)++toPair :: (a,a) -> Pair a+toPair (x,y) = Pair x y++swap :: Pair a -> Pair a+swap (Pair x y) = Pair y x++pLiftFst :: (a -> a) -> Pair a -> Pair a+pLiftFst f (Pair a b) = Pair (f a) b++pLiftSnd :: (a -> a) -> Pair a -> Pair a+pLiftSnd f (Pair a b) = Pair a (f b)
+ compiler/GHC/Data/Stream.hs view
@@ -0,0 +1,135 @@+-- -----------------------------------------------------------------------------+--+-- (c) The University of Glasgow 2012+--+-- -----------------------------------------------------------------------------++-- | Monadic streams+module GHC.Data.Stream (+    Stream(..), yield, liftIO,+    collect, collect_, consume, fromList,+    map, mapM, mapAccumL, mapAccumL_+  ) where++import GHC.Prelude hiding (map,mapM)++import Control.Monad hiding (mapM)++-- |+-- @Stream m a b@ is a computation in some Monad @m@ that delivers a sequence+-- of elements of type @a@ followed by a result of type @b@.+--+-- More concretely, a value of type @Stream m a b@ can be run using @runStream@+-- in the Monad @m@, and it delivers either+--+--  * the final result: @Left b@, or+--  * @Right (a,str)@, where @a@ is the next element in the stream, and @str@+--    is a computation to get the rest of the stream.+--+-- Stream is itself a Monad, and provides an operation 'yield' that+-- produces a new element of the stream.  This makes it convenient to turn+-- existing monadic computations into streams.+--+-- The idea is that Stream is useful for making a monadic computation+-- that produces values from time to time.  This can be used for+-- knitting together two complex monadic operations, so that the+-- producer does not have to produce all its values before the+-- consumer starts consuming them.  We make the producer into a+-- Stream, and the consumer pulls on the stream each time it wants a+-- new value.+--+newtype Stream m a b = Stream { runStream :: m (Either b (a, Stream m a b)) }++instance Monad f => Functor (Stream f a) where+  fmap = liftM++instance Monad m => Applicative (Stream m a) where+  pure a = Stream (return (Left a))+  (<*>) = ap++instance Monad m => Monad (Stream m a) where++  Stream m >>= k = Stream $ do+                r <- m+                case r of+                  Left b        -> runStream (k b)+                  Right (a,str) -> return (Right (a, str >>= k))++yield :: Monad m => a -> Stream m a ()+yield a = Stream (return (Right (a, return ())))++liftIO :: IO a -> Stream IO b a+liftIO io = Stream $ io >>= return . Left++-- | Turn a Stream into an ordinary list, by demanding all the elements.+collect :: Monad m => Stream m a () -> m [a]+collect str = go str []+ where+  go str acc = do+    r <- runStream str+    case r of+      Left () -> return (reverse acc)+      Right (a, str') -> go str' (a:acc)++-- | Turn a Stream into an ordinary list, by demanding all the elements.+collect_ :: Monad m => Stream m a r -> m ([a], r)+collect_ str = go str []+ where+  go str acc = do+    r <- runStream str+    case r of+      Left r -> return (reverse acc, r)+      Right (a, str') -> go str' (a:acc)++consume :: Monad m => Stream m a b -> (a -> m ()) -> m b+consume str f = do+    r <- runStream str+    case r of+      Left ret -> return ret+      Right (a, str') -> do+        f a+        consume str' f++-- | Turn a list into a 'Stream', by yielding each element in turn.+fromList :: Monad m => [a] -> Stream m a ()+fromList = mapM_ yield++-- | Apply a function to each element of a 'Stream', lazily+map :: Monad m => (a -> b) -> Stream m a x -> Stream m b x+map f str = Stream $ do+   r <- runStream str+   case r of+     Left x -> return (Left x)+     Right (a, str') -> return (Right (f a, map f str'))++-- | Apply a monadic operation to each element of a 'Stream', lazily+mapM :: Monad m => (a -> m b) -> Stream m a x -> Stream m b x+mapM f str = Stream $ do+   r <- runStream str+   case r of+     Left x -> return (Left x)+     Right (a, str') -> do+        b <- f a+        return (Right (b, mapM f str'))++-- | analog of the list-based 'mapAccumL' on Streams.  This is a simple+-- way to map over a Stream while carrying some state around.+mapAccumL :: Monad m => (c -> a -> m (c,b)) -> c -> Stream m a ()+          -> Stream m b c+mapAccumL f c str = Stream $ do+  r <- runStream str+  case r of+    Left  () -> return (Left c)+    Right (a, str') -> do+      (c',b) <- f c a+      return (Right (b, mapAccumL f c' str'))++mapAccumL_ :: Monad m => (c -> a -> m (c,b)) -> c -> Stream m a r+           -> Stream m b (c, r)+mapAccumL_ f c str = Stream $ do+  r <- runStream str+  case r of+    Left  r -> return (Left (c, r))+    Right (a, str') -> do+      (c',b) <- f c a+      return (Right (b, mapAccumL_ f c' str'))
+ compiler/GHC/Data/StringBuffer.hs view
@@ -0,0 +1,334 @@+{-+(c) The University of Glasgow 2006+(c) The University of Glasgow, 1997-2006+++Buffers for scanning string input stored in external arrays.+-}++{-# LANGUAGE BangPatterns, CPP, MagicHash, UnboxedTuples #-}+{-# OPTIONS_GHC -O2 #-}+-- We always optimise this, otherwise performance of a non-optimised+-- compiler is severely affected++module GHC.Data.StringBuffer+       (+        StringBuffer(..),+        -- non-abstract for vs\/HaskellService++         -- * Creation\/destruction+        hGetStringBuffer,+        hGetStringBufferBlock,+        hPutStringBuffer,+        appendStringBuffers,+        stringToStringBuffer,++        -- * Inspection+        nextChar,+        currentChar,+        prevChar,+        atEnd,++        -- * Moving and comparison+        stepOn,+        offsetBytes,+        byteDiff,+        atLine,++        -- * Conversion+        lexemeToString,+        lexemeToFastString,+        decodePrevNChars,++         -- * Parsing integers+        parseUnsignedInteger,+       ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Utils.Encoding+import GHC.Data.FastString+import GHC.Utils.IO.Unsafe+import GHC.Utils.Panic.Plain+import GHC.Utils.Misc++import Data.Maybe+import Control.Exception+import System.IO+import System.IO.Unsafe         ( unsafePerformIO )+import GHC.IO.Encoding.UTF8     ( mkUTF8 )+import GHC.IO.Encoding.Failure  ( CodingFailureMode(IgnoreCodingFailure) )++import GHC.Exts++import Foreign++-- -----------------------------------------------------------------------------+-- The StringBuffer type++-- |A StringBuffer is an internal pointer to a sized chunk of bytes.+-- The bytes are intended to be *immutable*.  There are pure+-- operations to read the contents of a StringBuffer.+--+-- A StringBuffer may have a finalizer, depending on how it was+-- obtained.+--+data StringBuffer+ = StringBuffer {+     buf :: {-# UNPACK #-} !(ForeignPtr Word8),+     len :: {-# UNPACK #-} !Int,        -- length+     cur :: {-# UNPACK #-} !Int         -- current pos+  }+  -- The buffer is assumed to be UTF-8 encoded, and furthermore+  -- we add three @\'\\0\'@ bytes to the end as sentinels so that the+  -- decoder doesn't have to check for overflow at every single byte+  -- of a multibyte sequence.++instance Show StringBuffer where+        showsPrec _ s = showString "<stringbuffer("+                      . shows (len s) . showString "," . shows (cur s)+                      . showString ")>"++-- -----------------------------------------------------------------------------+-- Creation / Destruction++-- | Read a file into a 'StringBuffer'.  The resulting buffer is automatically+-- managed by the garbage collector.+hGetStringBuffer :: FilePath -> IO StringBuffer+hGetStringBuffer fname = do+   h <- openBinaryFile fname ReadMode+   size_i <- hFileSize h+   offset_i <- skipBOM h size_i 0  -- offset is 0 initially+   let size = fromIntegral $ size_i - offset_i+   buf <- mallocForeignPtrArray (size+3)+   withForeignPtr buf $ \ptr -> do+     r <- if size == 0 then return 0 else hGetBuf h ptr size+     hClose h+     if (r /= size)+        then ioError (userError "short read of file")+        else newUTF8StringBuffer buf ptr size++hGetStringBufferBlock :: Handle -> Int -> IO StringBuffer+hGetStringBufferBlock handle wanted+    = do size_i <- hFileSize handle+         offset_i <- hTell handle >>= skipBOM handle size_i+         let size = min wanted (fromIntegral $ size_i-offset_i)+         buf <- mallocForeignPtrArray (size+3)+         withForeignPtr buf $ \ptr ->+             do r <- if size == 0 then return 0 else hGetBuf handle ptr size+                if r /= size+                   then ioError (userError $ "short read of file: "++show(r,size,size_i,handle))+                   else newUTF8StringBuffer buf ptr size++hPutStringBuffer :: Handle -> StringBuffer -> IO ()+hPutStringBuffer hdl (StringBuffer buf len cur)+    = do withForeignPtr (plusForeignPtr buf cur) $ \ptr ->+             hPutBuf hdl ptr len++-- | Skip the byte-order mark if there is one (see #1744 and #6016),+-- and return the new position of the handle in bytes.+--+-- This is better than treating #FEFF as whitespace,+-- because that would mess up layout.  We don't have a concept+-- of zero-width whitespace in Haskell: all whitespace codepoints+-- have a width of one column.+skipBOM :: Handle -> Integer -> Integer -> IO Integer+skipBOM h size offset =+  -- Only skip BOM at the beginning of a file.+  if size > 0 && offset == 0+    then do+      -- Validate assumption that handle is in binary mode.+      ASSERTM( hGetEncoding h >>= return . isNothing )+      -- Temporarily select utf8 encoding with error ignoring,+      -- to make `hLookAhead` and `hGetChar` return full Unicode characters.+      bracket_ (hSetEncoding h safeEncoding) (hSetBinaryMode h True) $ do+        c <- hLookAhead h+        if c == '\xfeff'+          then hGetChar h >> hTell h+          else return offset+    else return offset+  where+    safeEncoding = mkUTF8 IgnoreCodingFailure++newUTF8StringBuffer :: ForeignPtr Word8 -> Ptr Word8 -> Int -> IO StringBuffer+newUTF8StringBuffer buf ptr size = do+  pokeArray (ptr `plusPtr` size :: Ptr Word8) [0,0,0]+  -- sentinels for UTF-8 decoding+  return $ StringBuffer buf size 0++appendStringBuffers :: StringBuffer -> StringBuffer -> IO StringBuffer+appendStringBuffers sb1 sb2+    = do newBuf <- mallocForeignPtrArray (size+3)+         withForeignPtr newBuf $ \ptr ->+          withForeignPtr (buf sb1) $ \sb1Ptr ->+           withForeignPtr (buf sb2) $ \sb2Ptr ->+             do copyArray ptr (sb1Ptr `advancePtr` cur sb1) sb1_len+                copyArray (ptr `advancePtr` sb1_len) (sb2Ptr `advancePtr` cur sb2) sb2_len+                pokeArray (ptr `advancePtr` size) [0,0,0]+                return (StringBuffer newBuf size 0)+    where sb1_len = calcLen sb1+          sb2_len = calcLen sb2+          calcLen sb = len sb - cur sb+          size =  sb1_len + sb2_len++-- | Encode a 'String' into a 'StringBuffer' as UTF-8.  The resulting buffer+-- is automatically managed by the garbage collector.+stringToStringBuffer :: String -> StringBuffer+stringToStringBuffer str =+ unsafePerformIO $ do+  let size = utf8EncodedLength str+  buf <- mallocForeignPtrArray (size+3)+  withForeignPtr buf $ \ptr -> do+    utf8EncodeString ptr str+    pokeArray (ptr `plusPtr` size :: Ptr Word8) [0,0,0]+    -- sentinels for UTF-8 decoding+  return (StringBuffer buf size 0)++-- -----------------------------------------------------------------------------+-- Grab a character++-- | Return the first UTF-8 character of a nonempty 'StringBuffer' and as well+-- the remaining portion (analogous to 'Data.List.uncons').  __Warning:__ The+-- behavior is undefined if the 'StringBuffer' is empty.  The result shares+-- the same buffer as the original.  Similar to 'utf8DecodeChar', if the+-- character cannot be decoded as UTF-8, @\'\\0\'@ is returned.+{-# INLINE nextChar #-}+nextChar :: StringBuffer -> (Char,StringBuffer)+nextChar (StringBuffer buf len (I# cur#)) =+  -- Getting our fingers dirty a little here, but this is performance-critical+  inlinePerformIO $ do+    withForeignPtr buf $ \(Ptr a#) -> do+        case utf8DecodeChar# (a# `plusAddr#` cur#) of+          (# c#, nBytes# #) ->+             let cur' = I# (cur# +# nBytes#) in+             return (C# c#, StringBuffer buf len cur')++-- | Return the first UTF-8 character of a nonempty 'StringBuffer' (analogous+-- to 'Data.List.head').  __Warning:__ The behavior is undefined if the+-- 'StringBuffer' is empty.  Similar to 'utf8DecodeChar', if the character+-- cannot be decoded as UTF-8, @\'\\0\'@ is returned.+currentChar :: StringBuffer -> Char+currentChar = fst . nextChar++prevChar :: StringBuffer -> Char -> Char+prevChar (StringBuffer _   _   0)   deflt = deflt+prevChar (StringBuffer buf _   cur) _     =+  inlinePerformIO $ do+    withForeignPtr buf $ \p -> do+      p' <- utf8PrevChar (p `plusPtr` cur)+      return (fst (utf8DecodeChar p'))++-- -----------------------------------------------------------------------------+-- Moving++-- | Return a 'StringBuffer' with the first UTF-8 character removed (analogous+-- to 'Data.List.tail').  __Warning:__ The behavior is undefined if the+-- 'StringBuffer' is empty.  The result shares the same buffer as the+-- original.+stepOn :: StringBuffer -> StringBuffer+stepOn s = snd (nextChar s)++-- | Return a 'StringBuffer' with the first @n@ bytes removed.  __Warning:__+-- If there aren't enough characters, the returned 'StringBuffer' will be+-- invalid and any use of it may lead to undefined behavior.  The result+-- shares the same buffer as the original.+offsetBytes :: Int                      -- ^ @n@, the number of bytes+            -> StringBuffer+            -> StringBuffer+offsetBytes i s = s { cur = cur s + i }++-- | Compute the difference in offset between two 'StringBuffer's that share+-- the same buffer.  __Warning:__ The behavior is undefined if the+-- 'StringBuffer's use separate buffers.+byteDiff :: StringBuffer -> StringBuffer -> Int+byteDiff s1 s2 = cur s2 - cur s1++-- | Check whether a 'StringBuffer' is empty (analogous to 'Data.List.null').+atEnd :: StringBuffer -> Bool+atEnd (StringBuffer _ l c) = l == c++-- | Computes a 'StringBuffer' which points to the first character of the+-- wanted line. Lines begin at 1.+atLine :: Int -> StringBuffer -> Maybe StringBuffer+atLine line sb@(StringBuffer buf len _) =+  inlinePerformIO $+    withForeignPtr buf $ \p -> do+      p' <- skipToLine line len p+      if p' == nullPtr+        then return Nothing+        else+          let+            delta = p' `minusPtr` p+          in return $ Just (sb { cur = delta+                               , len = len - delta+                               })++skipToLine :: Int -> Int -> Ptr Word8 -> IO (Ptr Word8)+skipToLine !line !len !op0 = go 1 op0+  where+    !opend = op0 `plusPtr` len++    go !i_line !op+      | op >= opend    = pure nullPtr+      | i_line == line = pure op+      | otherwise      = do+          w <- peek op :: IO Word8+          case w of+            10 -> go (i_line + 1) (plusPtr op 1)+            13 -> do+              -- this is safe because a 'StringBuffer' is+              -- guaranteed to have 3 bytes sentinel values.+              w' <- peek (plusPtr op 1) :: IO Word8+              case w' of+                10 -> go (i_line + 1) (plusPtr op 2)+                _  -> go (i_line + 1) (plusPtr op 1)+            _  -> go i_line (plusPtr op 1)++-- -----------------------------------------------------------------------------+-- Conversion++-- | Decode the first @n@ bytes of a 'StringBuffer' as UTF-8 into a 'String'.+-- Similar to 'utf8DecodeChar', if the character cannot be decoded as UTF-8,+-- they will be replaced with @\'\\0\'@.+lexemeToString :: StringBuffer+               -> Int                   -- ^ @n@, the number of bytes+               -> String+lexemeToString _ 0 = ""+lexemeToString (StringBuffer buf _ cur) bytes =+  utf8DecodeStringLazy buf cur bytes++lexemeToFastString :: StringBuffer+                   -> Int               -- ^ @n@, the number of bytes+                   -> FastString+lexemeToFastString _ 0 = nilFS+lexemeToFastString (StringBuffer buf _ cur) len =+   inlinePerformIO $+     withForeignPtr buf $ \ptr ->+       return $! mkFastStringBytes (ptr `plusPtr` cur) len++-- | Return the previous @n@ characters (or fewer if we are less than @n@+-- characters into the buffer.+decodePrevNChars :: Int -> StringBuffer -> String+decodePrevNChars n (StringBuffer buf _ cur) =+    inlinePerformIO $ withForeignPtr buf $ \p0 ->+      go p0 n "" (p0 `plusPtr` (cur - 1))+  where+    go :: Ptr Word8 -> Int -> String -> Ptr Word8 -> IO String+    go buf0 n acc p | n == 0 || buf0 >= p = return acc+    go buf0 n acc p = do+        p' <- utf8PrevChar p+        let (c,_) = utf8DecodeChar p'+        go buf0 (n - 1) (c:acc) p'++-- -----------------------------------------------------------------------------+-- Parsing integer strings in various bases+parseUnsignedInteger :: StringBuffer -> Int -> Integer -> (Char->Int) -> Integer+parseUnsignedInteger (StringBuffer buf _ cur) len radix char_to_int+  = inlinePerformIO $ withForeignPtr buf $ \ptr -> return $! let+    go i x | i == len  = x+           | otherwise = case fst (utf8DecodeChar (ptr `plusPtr` (cur + i))) of+               '_'  -> go (i + 1) x    -- skip "_" (#14473)+               char -> go (i + 1) (x * radix + toInteger (char_to_int char))+  in go 0 0
+ compiler/GHC/Data/TrieMap.hs view
@@ -0,0 +1,406 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998+-}++{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE UndecidableInstances #-}+module GHC.Data.TrieMap(+   -- * Maps over 'Maybe' values+   MaybeMap,+   -- * Maps over 'List' values+   ListMap,+   -- * Maps over 'Literal's+   LiteralMap,+   -- * 'TrieMap' class+   TrieMap(..), insertTM, deleteTM,++   -- * Things helpful for adding additional Instances.+   (>.>), (|>), (|>>), XT,+   foldMaybe,+   -- * Map for leaf compression+   GenMap,+   lkG, xtG, mapG, fdG,+   xtList, lkList++ ) where++import GHC.Prelude++import GHC.Types.Literal+import GHC.Types.Unique.DFM+import GHC.Types.Unique( Unique )++import qualified Data.Map    as Map+import qualified Data.IntMap as IntMap+import GHC.Utils.Outputable+import Control.Monad( (>=>) )+import Data.Kind( Type )++{-+This module implements TrieMaps, which are finite mappings+whose key is a structured value like a CoreExpr or Type.++This file implements tries over general data structures.+Implementation for tries over Core Expressions/Types are+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+generalization of the Trie Data Structure"; there is also an accessible+description of the idea in Okasaki's book "Purely Functional Data+Structures", Section 10.3.2++************************************************************************+*                                                                      *+                   The TrieMap class+*                                                                      *+************************************************************************+-}++type XT a = Maybe a -> Maybe a  -- How to alter a non-existent elt (Nothing)+                                --               or an existing elt (Just)++class TrieMap m where+   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+   mapTM    :: (a->b) -> m a -> m b++   foldTM   :: (a -> b -> b) -> m a -> b -> b+      -- The unusual argument order here makes+      -- it easy to compose calls to foldTM;+      -- see for example fdE below++insertTM :: TrieMap m => Key m -> a -> m a -> m a+insertTM k v m = alterTM k (\_ -> Just v) m++deleteTM :: TrieMap m => Key m -> m a -> m a+deleteTM k m = alterTM k (\_ -> Nothing) m++----------------------+-- Recall that+--   Control.Monad.(>=>) :: (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c++(>.>) :: (a -> b) -> (b -> c) -> a -> c+-- Reverse function composition (do f first, then g)+infixr 1 >.>+(f >.> g) x = g (f x)+infixr 1 |>, |>>++(|>) :: a -> (a->b) -> b     -- Reverse application+x |> f = f x++----------------------+(|>>) :: TrieMap m2+      => (XT (m2 a) -> m1 (m2 a) -> m1 (m2 a))+      -> (m2 a -> m2 a)+      -> m1 (m2 a) -> m1 (m2 a)+(|>>) f g = f (Just . g . deMaybe)++deMaybe :: TrieMap m => Maybe (m a) -> m a+deMaybe Nothing  = emptyTM+deMaybe (Just m) = m++{-+************************************************************************+*                                                                      *+                   IntMaps+*                                                                      *+************************************************************************+-}++instance TrieMap IntMap.IntMap where+  type Key IntMap.IntMap = Int+  emptyTM = IntMap.empty+  lookupTM k m = IntMap.lookup k m+  alterTM = xtInt+  foldTM k m z = IntMap.foldr k z m+  mapTM f m = IntMap.map f m++xtInt :: Int -> XT a -> IntMap.IntMap a -> IntMap.IntMap a+xtInt k f m = IntMap.alter f k m++instance Ord k => TrieMap (Map.Map k) where+  type Key (Map.Map k) = k+  emptyTM = Map.empty+  lookupTM = Map.lookup+  alterTM k f m = Map.alter f k m+  foldTM k m z = Map.foldr k z m+  mapTM f m = Map.map f m+++{-+Note [foldTM determinism]+~~~~~~~~~~~~~~~~~~~~~~~~~+We want foldTM to be deterministic, which is why we have an instance of+TrieMap for UniqDFM, but not for UniqFM. Here's an example of some things that+go wrong if foldTM is nondeterministic. Consider:++  f a b = return (a <> b)++Depending on the order that the typechecker generates constraints you+get either:++  f :: (Monad m, Monoid a) => a -> a -> m a++or:++  f :: (Monoid a, Monad m) => a -> a -> m a++The generated code will be different after desugaring as the dictionaries+will be bound in different orders, leading to potential ABI incompatibility.++One way to solve this would be to notice that the typeclasses could be+sorted alphabetically.++Unfortunately that doesn't quite work with this example:++  f a b = let x = a <> a; y = b <> b in x++where you infer:++  f :: (Monoid m, Monoid m1) => m1 -> m -> m1++or:++  f :: (Monoid m1, Monoid m) => m1 -> m -> m1++Here you could decide to take the order of the type variables in the type+according to depth first traversal and use it to order the constraints.++The real trouble starts when the user enables incoherent instances and+the compiler has to make an arbitrary choice. Consider:++  class T a b where+    go :: a -> b -> String++  instance (Show b) => T Int b where+    go a b = show a ++ show b++  instance (Show a) => T a Bool where+    go a b = show a ++ show b++  f = go 10 True++GHC is free to choose either dictionary to implement f, but for the sake of+determinism we'd like it to be consistent when compiling the same sources+with the same flags.++inert_dicts :: DictMap is implemented with a TrieMap. In getUnsolvedInerts it+gets converted to a bag of (Wanted) Cts using a fold. Then in+solve_simple_wanteds it's merged with other WantedConstraints. We want the+conversion to a bag to be deterministic. For that purpose we use UniqDFM+instead of UniqFM to implement the TrieMap.++See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for more details on how it's made+deterministic.+-}++instance TrieMap UniqDFM where+  type Key UniqDFM = Unique+  emptyTM = emptyUDFM+  lookupTM k m = lookupUDFM m k+  alterTM k f m = alterUDFM f m k+  foldTM k m z = foldUDFM k z m+  mapTM f m = mapUDFM f m++{-+************************************************************************+*                                                                      *+                   Maybes+*                                                                      *+************************************************************************++If              m is a map from k -> val+then (MaybeMap m) is a map from (Maybe k) -> val+-}++data MaybeMap m a = MM { mm_nothing  :: Maybe a, mm_just :: m a }++instance TrieMap m => TrieMap (MaybeMap m) where+   type Key (MaybeMap m) = Maybe (Key m)+   emptyTM  = MM { mm_nothing = Nothing, mm_just = emptyTM }+   lookupTM = lkMaybe lookupTM+   alterTM  = xtMaybe alterTM+   foldTM   = fdMaybe+   mapTM    = mapMb++mapMb :: TrieMap m => (a->b) -> MaybeMap m a -> MaybeMap m b+mapMb f (MM { mm_nothing = mn, mm_just = mj })+  = MM { mm_nothing = fmap f mn, mm_just = mapTM f mj }++lkMaybe :: (forall b. k -> m b -> Maybe b)+        -> Maybe k -> MaybeMap m a -> Maybe a+lkMaybe _  Nothing  = mm_nothing+lkMaybe lk (Just x) = mm_just >.> lk x++xtMaybe :: (forall b. k -> XT b -> m b -> m b)+        -> Maybe k -> XT a -> MaybeMap m a -> MaybeMap m a+xtMaybe _  Nothing  f m = m { mm_nothing  = f (mm_nothing m) }+xtMaybe tr (Just x) f m = m { mm_just = mm_just m |> tr x f }++fdMaybe :: TrieMap m => (a -> b -> b) -> MaybeMap m a -> b -> b+fdMaybe k m = foldMaybe k (mm_nothing m)+            . foldTM k (mm_just m)++{-+************************************************************************+*                                                                      *+                   Lists+*                                                                      *+************************************************************************+-}++data ListMap m a+  = LM { lm_nil  :: Maybe a+       , lm_cons :: m (ListMap m a) }++instance TrieMap m => TrieMap (ListMap m) where+   type Key (ListMap m) = [Key m]+   emptyTM  = LM { lm_nil = Nothing, lm_cons = emptyTM }+   lookupTM = lkList lookupTM+   alterTM  = xtList alterTM+   foldTM   = fdList+   mapTM    = mapList++instance (TrieMap m, Outputable a) => Outputable (ListMap m a) where+  ppr m = text "List elts" <+> ppr (foldTM (:) m [])++mapList :: TrieMap m => (a->b) -> ListMap m a -> ListMap m b+mapList f (LM { lm_nil = mnil, lm_cons = mcons })+  = LM { lm_nil = fmap f mnil, lm_cons = mapTM (mapTM f) mcons }++lkList :: TrieMap m => (forall b. k -> m b -> Maybe b)+        -> [k] -> ListMap m a -> Maybe a+lkList _  []     = lm_nil+lkList lk (x:xs) = lm_cons >.> lk x >=> lkList lk xs++xtList :: TrieMap m => (forall b. k -> XT b -> m b -> m b)+        -> [k] -> XT a -> ListMap m a -> ListMap m a+xtList _  []     f m = m { lm_nil  = f (lm_nil m) }+xtList tr (x:xs) f m = m { lm_cons = lm_cons m |> tr x |>> xtList tr xs f }++fdList :: forall m a b. TrieMap m+       => (a -> b -> b) -> ListMap m a -> b -> b+fdList k m = foldMaybe k          (lm_nil m)+           . foldTM    (fdList k) (lm_cons m)++foldMaybe :: (a -> b -> b) -> Maybe a -> b -> b+foldMaybe _ Nothing  b = b+foldMaybe k (Just a) b = k a b++{-+************************************************************************+*                                                                      *+                   Basic maps+*                                                                      *+************************************************************************+-}++type LiteralMap  a = Map.Map Literal a++{-+************************************************************************+*                                                                      *+                   GenMap+*                                                                      *+************************************************************************++Note [Compressed TrieMap]+~~~~~~~~~~~~~~~~~~~~~~~~~++The GenMap constructor augments TrieMaps with leaf compression.  This helps+solve the performance problem detailed in #9960: suppose we have a handful+H of entries in a TrieMap, each with a very large key, size K. If you fold over+such a TrieMap you'd expect time O(H). That would certainly be true of an+association list! But with TrieMap we actually have to navigate down a long+singleton structure to get to the elements, so it takes time O(K*H).  This+can really hurt on many type-level computation benchmarks:+see for example T9872d.++The point of a TrieMap is that you need to navigate to the point where only one+key remains, and then things should be fast.  So the point of a SingletonMap+is that, once we are down to a single (key,value) pair, we stop and+just use SingletonMap.++'EmptyMap' provides an even more basic (but essential) optimization: if there is+nothing in the map, don't bother building out the (possibly infinite) recursive+TrieMap structure!++Compressed triemaps are heavily used by GHC.Core.Map. So we have to mark some things+as INLINEABLE to permit specialization.+-}++data GenMap m a+   = EmptyMap+   | SingletonMap (Key m) a+   | MultiMap (m a)++instance (Outputable a, Outputable (m a)) => Outputable (GenMap m a) where+  ppr EmptyMap = text "Empty map"+  ppr (SingletonMap _ v) = text "Singleton map" <+> ppr v+  ppr (MultiMap m) = ppr m++-- TODO undecidable instance+instance (Eq (Key m), TrieMap m) => TrieMap (GenMap m) where+   type Key (GenMap m) = Key m+   emptyTM  = EmptyMap+   lookupTM = lkG+   alterTM  = xtG+   foldTM   = fdG+   mapTM    = mapG++--We want to be able to specialize these functions when defining eg+--tries over (GenMap CoreExpr) which requires INLINEABLE++{-# INLINEABLE lkG #-}+lkG :: (Eq (Key m), TrieMap m) => Key m -> GenMap m a -> Maybe a+lkG _ EmptyMap                         = Nothing+lkG k (SingletonMap k' v') | k == k'   = Just v'+                           | otherwise = Nothing+lkG k (MultiMap m)                     = lookupTM k m++{-# INLINEABLE xtG #-}+xtG :: (Eq (Key m), TrieMap m) => Key m -> XT a -> GenMap m a -> GenMap m a+xtG k f EmptyMap+    = case f Nothing of+        Just v  -> SingletonMap k v+        Nothing -> EmptyMap+xtG k f m@(SingletonMap k' v')+    | k' == k+    -- The new key matches the (single) key already in the tree.  Hence,+    -- apply @f@ to @Just v'@ and build a singleton or empty map depending+    -- on the 'Just'/'Nothing' response respectively.+    = case f (Just v') of+        Just v'' -> SingletonMap k' v''+        Nothing  -> EmptyMap+    | otherwise+    -- We've hit a singleton tree for a different key than the one we are+    -- searching for. Hence apply @f@ to @Nothing@. If result is @Nothing@ then+    -- we can just return the old map. If not, we need a map with *two*+    -- entries. The easiest way to do that is to insert two items into an empty+    -- map of type @m a@.+    = case f Nothing of+        Nothing  -> m+        Just v   -> emptyTM |> alterTM k' (const (Just v'))+                           >.> alterTM k  (const (Just v))+                           >.> MultiMap+xtG k f (MultiMap m) = MultiMap (alterTM k f m)++{-# INLINEABLE mapG #-}+mapG :: TrieMap m => (a -> b) -> GenMap m a -> GenMap m b+mapG _ EmptyMap = EmptyMap+mapG f (SingletonMap k v) = SingletonMap k (f v)+mapG f (MultiMap m) = MultiMap (mapTM f m)++{-# INLINEABLE fdG #-}+fdG :: TrieMap m => (a -> b -> b) -> GenMap m a -> b -> b+fdG _ EmptyMap = \z -> z+fdG k (SingletonMap _ v) = \z -> k v z+fdG k (MultiMap m) = foldTM k m
compiler/GHC/Driver/Backpack/Syntax.hs view
@@ -16,14 +16,13 @@     LRenaming, Renaming(..),     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Driver.Phases import GHC.Hs import GHC.Types.SrcLoc-import Outputable-import GHC.Types.Module-import UnitInfo+import GHC.Utils.Outputable+import GHC.Unit  {- ************************************************************************@@ -35,7 +34,7 @@  data HsComponentId = HsComponentId {     hsPackageName :: PackageName,-    hsComponentId :: ComponentId+    hsComponentId :: IndefUnitId     }  instance Outputable HsComponentId where
compiler/GHC/Driver/CmdLine.hs view
@@ -26,14 +26,14 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import Util-import Outputable-import Panic-import Bag+import GHC.Utils.Misc+import GHC.Utils.Outputable+import GHC.Utils.Panic+import GHC.Data.Bag import GHC.Types.SrcLoc-import Json+import GHC.Utils.Json  import Data.Function import Data.List
compiler/GHC/Driver/Flags.hs view
@@ -8,10 +8,10 @@    ) where -import GhcPrelude-import Outputable-import EnumSet-import Json+import GHC.Prelude+import GHC.Utils.Outputable+import GHC.Data.EnumSet as EnumSet+import GHC.Utils.Json  -- | Debugging flags data DumpFlag@@ -79,6 +79,7 @@    | Opt_D_dump_cpr_signatures    | Opt_D_dump_tc    | Opt_D_dump_tc_ast+   | Opt_D_dump_hie    | Opt_D_dump_types    | Opt_D_dump_rules    | Opt_D_dump_cse@@ -183,7 +184,7 @@    | Opt_CmmElimCommonBlocks    | Opt_AsmShortcutting    | Opt_OmitYields-   | Opt_FunToThunk               -- allow GHC.Core.Op.WorkWrap.Lib.mkWorkerArgs to remove all value lambdas+   | Opt_FunToThunk               -- allow GHC.Core.Opt.WorkWrap.Utils.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]@@ -283,7 +284,7 @@    | 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+    -- See Note [Valid hole fits include] in GHC.Tc.Errors.Hole    | Opt_ShowValidHoleFits    | Opt_SortValidHoleFits    | Opt_SortBySizeHoleFits@@ -350,7 +351,7 @@  -- 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+-- Note [Ignoring some flag changes] in GHC.Iface.Recomp.Flags). 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
compiler/GHC/Driver/Hooks.hs view
@@ -28,7 +28,7 @@    ) where -import GhcPrelude+import GHC.Prelude  import GHC.Driver.Session import GHC.Driver.Pipeline.Monad@@ -36,9 +36,9 @@ import GHC.Hs.Decls import GHC.Hs.Binds import GHC.Hs.Expr-import OrdList-import TcRnTypes-import Bag+import GHC.Data.OrdList+import GHC.Tc.Types+import GHC.Data.Bag import GHC.Types.Name.Reader import GHC.Types.Name import GHC.Types.Id@@ -48,11 +48,11 @@ import GHC.Core.Type import System.Process import GHC.Types.Basic-import GHC.Types.Module+import GHC.Unit.Module import GHC.Core.TyCon import GHC.Types.CostCentre import GHC.Stg.Syntax-import Stream+import GHC.Data.Stream import GHC.Cmm import GHC.Hs.Extension
compiler/GHC/Driver/Hooks.hs-boot view
@@ -1,6 +1,6 @@ module GHC.Driver.Hooks where -import GhcPrelude ()+import GHC.Prelude ()  data Hooks
compiler/GHC/Driver/Monad.hs view
@@ -23,13 +23,13 @@         WarnErrLogger, defaultWarnErrLogger   ) where -import GhcPrelude+import GHC.Prelude -import MonadUtils+import GHC.Utils.Monad import GHC.Driver.Types import GHC.Driver.Session-import Exception-import ErrUtils+import GHC.Utils.Exception+import GHC.Utils.Error  import Control.Monad import Data.IORef
− compiler/GHC/Driver/Packages.hs 
@@ -1,2250 +0,0 @@--- (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,-        getPackageState,-        getPreloadPackagesAnd,--        collectArchives,-        collectIncludeDirs, collectLibraryPaths, collectLinkOpts,-        packageHsLibs, getLibs,--        -- * Utils-        mkComponentId,-        updateComponentId,-        unwireUnitId,-        pprFlag,-        pprPackages,-        pprPackagesSimple,-        pprModuleMap,-        isIndefinite,-        isDynLinkName-    )-where--#include "HsVersions.h"--import GhcPrelude--import GHC.PackageDb-import UnitInfo-import GHC.Driver.Session-import GHC.Driver.Ways-import GHC.Types.Name       ( Name, nameModule_maybe )-import GHC.Types.Unique.FM-import GHC.Types.Unique.DFM-import GHC.Types.Unique.Set-import GHC.Types.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 :: PackageState -> ComponentId -> Maybe UnitInfo-lookupComponentId pkgstate (ComponentId cid_fs) = lookupUDFM pkg_map cid_fs-  where-    UnitInfoMap pkg_map = unitInfoMap pkgstate--}---- | 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 :: PackageState -> PackageName -> Maybe ComponentId-lookupPackageName pkgstate n = Map.lookup n (packageNameMap pkgstate)---- | Search for packages with a given package ID (e.g. \"foo-0.1\")-searchPackageId :: PackageState -> SourcePackageId -> [UnitInfo]-searchPackageId pkgstate pid = filter ((pid ==) . sourcePackageId)-                               (listUnitInfoMap pkgstate)---- | 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 :: PackageState -> InstalledUnitId -> Maybe UnitInfo-lookupInstalledPackage pkgstate uid = lookupInstalledPackage' (unitInfoMap pkgstate) uid--lookupInstalledPackage' :: UnitInfoMap -> InstalledUnitId -> Maybe UnitInfo-lookupInstalledPackage' (UnitInfoMap db _) uid = lookupUDFM db uid--getInstalledPackageDetails :: HasDebugCallStack => PackageState -> InstalledUnitId -> UnitInfo-getInstalledPackageDetails pkgstate uid =-    case lookupInstalledPackage pkgstate 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 :: PackageState -> [UnitInfo]-listUnitInfoMap pkgstate = eltsUDFM pkg_map-  where-    UnitInfoMap pkg_map _ = unitInfoMap pkgstate---- ------------------------------------------------------------------------------- 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 GHC.Types.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 GHC.Types.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-        pkgstate = pkgState dflags--        -- 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 = mkComponentId pkgstate 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 GHC.Types.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 = Set.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 `Set.member` ways1 || WayProf `Set.member` ways1-              = Set.filter (/= WayEventLog) ways1-              | otherwise-              = ways1--        tag     = waysTag (Set.filter (not . wayRTSOnly) ways2)-        rts_tag = waysTag ways2--        mkDynName x-         | WayDyn `Set.notMember` 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 state) 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 :: ComponentId -> String-componentIdString (ComponentId  raw Nothing)        = unpackFS raw-componentIdString (ComponentId _raw (Just details)) =-   case componentName details of-     Nothing    -> componentSourcePkdId details-     Just cname -> componentPackageName details-                     ++ "-" ++ showVersion (componentPackageVersion details)-                     ++ ":" ++ cname---- Cabal packages may contain several components (programs, libraries, etc.).--- As far as GHC is concerned, installed package components ("units") are--- identified by an opaque ComponentId string provided by Cabal. As the string--- contains a hash, we don't want to display it to users so GHC queries the--- database to retrieve some infos about the original source package (name,--- version, component name).------ Instead we want to display: packagename-version[:componentname]------ Component name is only displayed if it isn't the default library------ To do this we need to query the database (cached in DynFlags). We cache--- these details in the ComponentId itself because we don't want to query--- DynFlags each time we pretty-print the ComponentId----mkComponentId :: PackageState -> FastString -> ComponentId-mkComponentId pkgstate raw =-    case lookupInstalledPackage pkgstate (InstalledUnitId raw) of-      Nothing -> ComponentId raw Nothing -- we didn't find the unit at all-      Just c  -> ComponentId raw $ Just $ ComponentDetails-                                             (packageNameString c)-                                             (packageVersion c)-                                             ((unpackFS . unPackageName) <$> sourceLibName c)-                                             (sourcePackageIdString c)---- | Update component ID details from the database-updateComponentId :: PackageState -> ComponentId -> ComponentId-updateComponentId pkgstate (ComponentId raw _) = mkComponentId pkgstate raw---displayInstalledUnitId :: PackageState -> InstalledUnitId -> Maybe String-displayInstalledUnitId pkgstate uid =-    fmap sourcePackageIdString (lookupInstalledPackage pkgstate uid)---- | Will the 'Name' come from a dynamically linked package?-isDynLinkName :: DynFlags -> Module -> Name -> Bool-isDynLinkName 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.-    ---    -- 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 :: PackageState -> SDoc-pprPackages = pprPackagesWith pprUnitInfo--pprPackagesWith :: (UnitInfo -> SDoc) -> PackageState -> SDoc-pprPackagesWith pprIPI pkgstate =-    vcat (intersperse (text "---") (map pprIPI (listUnitInfoMap pkgstate)))---- | 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 :: PackageState -> 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---- | Retrieve the 'PackageState' from 'DynFlags'; used--- in the @hs-boot@ loop-breaker.-getPackageState :: DynFlags -> PackageState-getPackageState = pkgState
− compiler/GHC/Driver/Packages.hs-boot 
@@ -1,15 +0,0 @@-module GHC.Driver.Packages where-import GhcPrelude-import FastString-import {-# SOURCE #-} GHC.Driver.Session (DynFlags)-import {-# SOURCE #-} GHC.Types.Module(ComponentId, UnitId, InstalledUnitId)-data PackageState-data UnitInfoMap-data PackageDatabase-emptyPackageState :: PackageState-componentIdString :: ComponentId -> String-mkComponentId :: PackageState -> FastString -> ComponentId-displayInstalledUnitId :: PackageState -> InstalledUnitId -> Maybe String-improveUnitId :: UnitInfoMap -> UnitId -> UnitId-getUnitInfoMap :: DynFlags -> UnitInfoMap-getPackageState :: DynFlags -> PackageState
compiler/GHC/Driver/Phases.hs view
@@ -39,13 +39,13 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable import GHC.Platform import System.FilePath-import Binary-import Util+import GHC.Utils.Binary+import GHC.Utils.Misc  ----------------------------------------------------------------------------- -- Phases
compiler/GHC/Driver/Pipeline/Monad.hs view
@@ -11,15 +11,15 @@   , pipeStateDynFlags, pipeStateModIface   ) where -import GhcPrelude+import GHC.Prelude -import MonadUtils-import Outputable+import GHC.Utils.Monad+import GHC.Utils.Outputable import GHC.Driver.Session import GHC.Driver.Phases import GHC.Driver.Types-import GHC.Types.Module-import FileCleanup (TempFileLifetime)+import GHC.Unit.Module+import GHC.SysTools.FileCleanup (TempFileLifetime)  import Control.Monad
compiler/GHC/Driver/Plugins.hs view
@@ -47,21 +47,21 @@     , mapPlugins, withPlugins, withPlugins_     ) where -import GhcPrelude+import GHC.Prelude -import {-# SOURCE #-} GHC.Core.Op.Monad ( CoreToDo, CoreM )-import qualified TcRnTypes-import TcRnTypes ( TcGblEnv, IfM, TcM, tcg_rn_decls, tcg_rn_exports  )-import TcHoleFitTypes ( HoleFitPluginR )+import {-# SOURCE #-} GHC.Core.Opt.Monad ( CoreToDo, CoreM )+import qualified GHC.Tc.Types+import GHC.Tc.Types ( TcGblEnv, IfM, TcM, tcg_rn_decls, tcg_rn_exports  )+import GHC.Tc.Errors.Hole.FitTypes ( HoleFitPluginR ) import GHC.Hs import GHC.Driver.Session import GHC.Driver.Types import GHC.Driver.Monad import GHC.Driver.Phases-import GHC.Types.Module ( ModuleName, Module(moduleName))-import Fingerprint+import GHC.Unit.Module+import GHC.Utils.Fingerprint import Data.List (sort)-import Outputable (Outputable(..), text, (<+>))+import GHC.Utils.Outputable (Outputable(..), text, (<+>))  --Qualified import so we can define a Semigroup instance -- but it doesn't clash with Outputable.<>@@ -188,7 +188,7 @@   mempty = NoForceRecompile  type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]-type TcPlugin = [CommandLineOption] -> Maybe TcRnTypes.TcPlugin+type TcPlugin = [CommandLineOption] -> Maybe GHC.Tc.Types.TcPlugin type HoleFitPlugin = [CommandLineOption] -> Maybe HoleFitPluginR  purePlugin, impurePlugin, flagRecompile :: [CommandLineOption] -> IO PluginRecompile
compiler/GHC/Driver/Plugins.hs-boot view
@@ -2,7 +2,7 @@ -- exposed without importing all of its implementation. module GHC.Driver.Plugins where -import GhcPrelude ()+import GHC.Prelude ()  data Plugin
compiler/GHC/Driver/Session.hs view
@@ -231,7 +231,7 @@         IncludeSpecs(..), addGlobalInclude, addQuoteInclude, flattenIncludes,          -- * SDoc-        initSDocContext,+        initSDocContext, initDefaultSDocContext,          -- * Make use of the Cmm CFG         CfgWeights(..)@@ -239,46 +239,45 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Platform import GHC.UniqueSubdir (uniqueSubdir)-import PlatformConstants-import GHC.Types.Module+import GHC.Unit.Types+import GHC.Unit.Parser+import GHC.Unit.Module import {-# SOURCE #-} GHC.Driver.Plugins import {-# SOURCE #-} GHC.Driver.Hooks-import {-# SOURCE #-} PrelNames ( mAIN )-import {-# SOURCE #-} GHC.Driver.Packages (PackageState, emptyPackageState, PackageDatabase, mkComponentId)+import {-# SOURCE #-} GHC.Builtin.Names ( mAIN )+import {-# SOURCE #-} GHC.Unit.State (PackageState, emptyPackageState, PackageDatabase, mkIndefUnitId, updateIndefUnitId) import GHC.Driver.Phases ( Phase(..), phaseInputExt ) import GHC.Driver.Flags import GHC.Driver.Ways import Config-import CliOption+import GHC.Utils.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 GHC.Settings.Constants+import GHC.Utils.Panic+import qualified GHC.Utils.Ppr.Colour as Col+import GHC.Utils.Misc+import GHC.Data.Maybe+import GHC.Utils.Monad+import qualified GHC.Utils.Ppr as Pretty import GHC.Types.SrcLoc import GHC.Types.Basic ( Alignment, alignmentOf, IntWithInf, treatZeroAsInf )-import FastString-import Fingerprint-import FileSettings-import Outputable-import Settings-import ToolSettings+import GHC.Data.FastString+import GHC.Utils.Fingerprint+import GHC.Utils.Outputable+import GHC.Settings -import {-# SOURCE #-} ErrUtils ( Severity(..), MsgDoc, mkLocMessageAnn+import {-# SOURCE #-} GHC.Utils.Error+                               ( Severity(..), MsgDoc, mkLocMessageAnn                                , getCaretDiagnostic, DumpAction, TraceAction                                , defaultDumpAction, defaultTraceAction )-import Json-import SysTools.Terminal ( stderrSupportsAnsiColors )-import SysTools.BaseDir ( expandToolDir, expandTopDir )+import GHC.Utils.Json+import GHC.SysTools.Terminal ( stderrSupportsAnsiColors )+import GHC.SysTools.BaseDir ( expandToolDir, expandTopDir )  import System.IO.Unsafe ( unsafePerformIO ) import Data.IORef@@ -305,8 +304,8 @@ import Text.ParserCombinators.ReadP hiding (char) import Text.ParserCombinators.ReadP as R -import EnumSet (EnumSet)-import qualified EnumSet+import GHC.Data.EnumSet (EnumSet)+import qualified GHC.Data.EnumSet as EnumSet  import GHC.Foreign (withCString, peekCString) import qualified GHC.LanguageExtensions as LangExt@@ -458,10 +457,10 @@    integerLibrary        :: IntegerLibrary,     -- ^ IntegerGMP or IntegerSimple. Set at configure time, but may be overridden-    --   by GHC-API users. See Note [The integer library] in PrelNames+    --   by GHC-API users. See Note [The integer library] in GHC.Builtin.Names   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.+    -- configuration lazily. See Note [LLVM Configuration] in GHC.SysTools.   verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]   optLevel              :: Int,         -- ^ Optimisation level   debugLevel            :: Int,         -- ^ How much debug information to produce@@ -504,7 +503,7 @@                                         --   by the assembler code generator (0 to disable)   liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase   floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating-                                        --   See GHC.Core.Op.Monad.FloatOutSwitches+                                        --   See GHC.Core.Opt.Monad.FloatOutSwitches    liftLamsRecArgs       :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a                                         --   recursive function.@@ -524,9 +523,9 @@   solverIterations      :: IntWithInf,   -- ^ Number of iterations in the constraints solver                                          --   Typically only 1 is needed -  thisInstalledUnitId   :: InstalledUnitId,-  thisComponentId_      :: Maybe ComponentId,-  thisUnitIdInsts_      :: Maybe [(ModuleName, Module)],+  thisUnitId   :: UnitId,              -- ^ Target unit-id+  thisComponentId_      :: Maybe IndefUnitId,            -- ^ Unit-id to instantiate+  thisUnitIdInsts_      :: Maybe [(ModuleName, Module)], -- ^ How to instantiate the unit-id above    -- ways   ways                  :: Set Way,     -- ^ Way flags from the command line@@ -630,11 +629,11 @@   packageEnv            :: Maybe FilePath,         -- ^ Filepath to the package environment file (if overriding default) -  pkgDatabase           :: Maybe [PackageDatabase],+  pkgDatabase           :: Maybe [PackageDatabase UnitId],         -- ^ 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]).+        -- database (cf Note [About Units]).         --         -- This field is populated by `initPackages`.         --@@ -700,7 +699,6 @@   ufUseThreshold        :: Int,   ufFunAppDiscount      :: Int,   ufDictDiscount        :: Int,-  ufKeenessFactor       :: Float,   ufDearOp              :: Int,   ufVeryAggressive      :: Bool, @@ -708,7 +706,7 @@    ghciHistSize          :: Int, -  -- | MsgDoc output action: use "ErrUtils" instead of this if you can+  -- | MsgDoc output action: use "GHC.Utils.Error" instead of this if you can   log_action            :: LogAction,   dump_action           :: DumpAction,   trace_action          :: TraceAction,@@ -890,7 +888,7 @@   , lAttributes :: [String]   } --- | See Note [LLVM Configuration] in SysTools.+-- | See Note [LLVM Configuration] in GHC.SysTools. data LlvmConfig = LlvmConfig { llvmTargets :: [(String, LlvmTarget)]                              , llvmPasses  :: [(Int, String)]                              }@@ -1093,8 +1091,9 @@ -- is used. data PackageArg =       PackageArg String    -- ^ @-package@, by 'PackageName'-    | UnitIdArg UnitId     -- ^ @-package-id@, by 'UnitId'+    | UnitIdArg Unit       -- ^ @-package-id@, by 'Unit'   deriving (Eq, Show)+ instance Outputable PackageArg where     ppr (PackageArg pn) = text "package" <+> text pn     ppr (UnitIdArg uid) = text "unit" <+> ppr uid@@ -1254,7 +1253,6 @@                          `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@@ -1271,7 +1269,7 @@         nextWrapperNum = wrapperNum,         useUnicode    = useUnicode',         useColor      = useColor',-        canUseColor   = canUseColor,+        canUseColor   = stderrSupportsAnsiColors,         colScheme     = colScheme',         rtldInfo      = refRtldInfo,         rtccInfo      = refRtccInfo@@ -1326,7 +1324,7 @@         reductionDepth          = treatZeroAsInf mAX_REDUCTION_DEPTH,         solverIterations        = treatZeroAsInf mAX_SOLVER_ITERATIONS, -        thisInstalledUnitId     = toInstalledUnitId mainUnitId,+        thisUnitId     = toUnitId mainUnitId,         thisUnitIdInsts_        = Nothing,         thisComponentId_        = Nothing, @@ -1432,12 +1430,11 @@         -- into Csg.calc (The unfolding for sqr never makes it into the         -- interface file.)         ufCreationThreshold = 750,-        ufUseThreshold      = 60,+        ufUseThreshold      = 80,         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, @@ -1596,7 +1593,8 @@ 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+  = printSDoc ctx Pretty.PageMode h d+    where ctx = initSDocContext dflags sty  newtype FlushOut = FlushOut (IO ()) @@ -1958,16 +1956,16 @@ setJsonLogAction :: DynFlags -> DynFlags setJsonLogAction d = d { log_action = jsonLogAction } -thisComponentId :: DynFlags -> ComponentId+thisComponentId :: DynFlags -> IndefUnitId thisComponentId dflags =   let pkgstate = pkgState dflags   in case thisComponentId_ dflags of-    Just (ComponentId raw _) -> mkComponentId pkgstate raw+    Just uid -> updateIndefUnitId pkgstate uid     Nothing  ->       case thisUnitIdInsts_ dflags of         Just _  ->           throwGhcException $ CmdLineError ("Use of -instantiated-with requires -this-component-id")-        Nothing -> mkComponentId pkgstate (unitIdFS (thisPackage dflags))+        Nothing -> mkIndefUnitId pkgstate (unitFS (thisPackage dflags))  thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)] thisUnitIdInsts dflags =@@ -1975,36 +1973,36 @@         Just insts -> insts         Nothing    -> [] -thisPackage :: DynFlags -> UnitId+thisPackage :: DynFlags -> Unit thisPackage dflags =     case thisUnitIdInsts_ dflags of         Nothing -> default_uid         Just insts           | all (\(x,y) -> mkHoleModule x == y) insts-          -> newUnitId (thisComponentId dflags) insts+          -> mkVirtUnit (thisComponentId dflags) insts           | otherwise           -> default_uid   where-    default_uid = DefiniteUnitId (DefUnitId (thisInstalledUnitId dflags))+    default_uid = RealUnit (Definite (thisUnitId dflags)) -parseUnitIdInsts :: String -> [(ModuleName, Module)]-parseUnitIdInsts str = case filter ((=="").snd) (readP_to_S parse str) of+parseUnitInsts :: String -> Instantiations+parseUnitInsts 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+            m <- parseHoleyModule             return (n, m)  setUnitIdInsts :: String -> DynFlags -> DynFlags setUnitIdInsts s d =-    d { thisUnitIdInsts_ = Just (parseUnitIdInsts s) }+    d { thisUnitIdInsts_ = Just (parseUnitInsts s) }  setComponentId :: String -> DynFlags -> DynFlags setComponentId s d =-    d { thisComponentId_ = Just (ComponentId (fsLit s) Nothing) }+    d { thisComponentId_ = Just (Indefinite (UnitId (fsLit s)) Nothing) }  addPluginModuleName :: String -> DynFlags -> DynFlags addPluginModuleName name d = d { pluginModNames = (mkModuleName name) : (pluginModNames d) }@@ -2665,6 +2663,8 @@         (setDumpFlag Opt_D_dump_cmm_info)   , make_ord_flag defGhcFlag "ddump-cmm-cps"         (setDumpFlag Opt_D_dump_cmm_cps)+  , make_ord_flag defGhcFlag "ddump-cmm-opt"+        (setDumpFlag Opt_D_dump_opt_cmm)   , make_ord_flag defGhcFlag "ddump-cfg-weights"         (setDumpFlag Opt_D_dump_cfg_weights)   , make_ord_flag defGhcFlag "ddump-core-stats"@@ -2743,6 +2743,8 @@         (setDumpFlag Opt_D_dump_tc)   , make_ord_flag defGhcFlag "ddump-tc-ast"         (setDumpFlag Opt_D_dump_tc_ast)+  , make_ord_flag defGhcFlag "ddump-hie"+        (setDumpFlag Opt_D_dump_hie)   , make_ord_flag defGhcFlag "ddump-types"         (setDumpFlag Opt_D_dump_types)   , make_ord_flag defGhcFlag "ddump-rules"@@ -2771,7 +2773,7 @@    , make_ord_flag defGhcFlag "ddump-rn-stats"         (setDumpFlag Opt_D_dump_rn_stats)-  , make_ord_flag defGhcFlag "ddump-opt-cmm"+  , make_ord_flag defGhcFlag "ddump-opt-cmm" --old alias for cmm-opt         (setDumpFlag Opt_D_dump_opt_cmm)   , make_ord_flag defGhcFlag "ddump-simpl-stats"         (setDumpFlag Opt_D_dump_simpl_stats)@@ -2821,8 +2823,6 @@         (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"@@ -3023,8 +3023,9 @@       (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_dep_flag defFlag "funfolding-keeness-factor"+      (floatSuffix (\_ d -> d))+      "-funfolding-keeness-factor is no longer respected as of GHC 8.12"   , make_ord_flag defFlag "fmax-worker-args"       (intSuffix (\n d -> d {maxWorkerArgs = n}))   , make_ord_flag defGhciFlag "fghci-hist-size"@@ -3631,7 +3632,7 @@  -- | 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+-- in the GHC.Tc.Errors.Hole module. These flags can all be reversed with -- @-fno-\<blah\>@ fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)] fHoleFlags = [@@ -3926,7 +3927,7 @@  -- | 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.+ -- in the GHC.Tc.Errors.Hole module. validHoleFitDefaults :: [GeneralFlag] validHoleFitDefaults   =  [ Opt_ShowTypeAppOfHoleFits@@ -4557,13 +4558,13 @@ exposePackage p = upd (exposePackage' p) exposePackageId p =   upd (\s -> s{ packageFlags =-    parsePackageFlag "-package-id" parseUnitIdArg p : packageFlags s })+    parsePackageFlag "-package-id" parseUnitArg 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 })+    parsePackageFlag "-plugin-package-id" parseUnitArg p : pluginPackageFlags s }) hidePackage p =   upd (\s -> s{ packageFlags = HidePackage p : packageFlags s }) ignorePackage p =@@ -4583,12 +4584,12 @@ parsePackageArg =     fmap PackageArg (munch1 (\c -> isAlphaNum c || c `elem` ":-_.")) -parseUnitIdArg :: ReadP PackageArg-parseUnitIdArg =-    fmap UnitIdArg parseUnitId+parseUnitArg :: ReadP PackageArg+parseUnitArg =+    fmap UnitIdArg parseUnit  setUnitId :: String -> DynFlags -> DynFlags-setUnitId p d = d { thisInstalledUnitId = stringToInstalledUnitId p }+setUnitId p d = d { thisUnitId = stringToUnitId p }  -- | Given a 'ModuleName' of a signature in the home library, find -- out how it is instantiated.  E.g., the canonical form of@@ -4601,7 +4602,7 @@  canonicalizeModuleIfHome :: DynFlags -> Module -> Module canonicalizeModuleIfHome dflags mod-    = if thisPackage dflags == moduleUnitId mod+    = if thisPackage dflags == moduleUnit mod                       then canonicalizeHomeModule dflags (moduleName mod)                       else mod @@ -5058,13 +5059,6 @@ -- 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@@ -5110,10 +5104,6 @@ -- ----------------------------------------------------------------------------- -- BMI2 -data BmiVersion = BMI1-                | BMI2-                deriving (Eq, Ord)- isBmiEnabled :: DynFlags -> Bool isBmiEnabled dflags = case platformArch (targetPlatform dflags) of     ArchX86_64 -> bmiVersion dflags >= Just BMI1@@ -5189,7 +5179,7 @@ emptyFilesToClean = FilesToClean Set.empty Set.empty  -+-- | Initialize the pretty-printing options initSDocContext :: DynFlags -> PprStyle -> SDocContext initSDocContext dflags style = SDC   { sdocStyle                       = style@@ -5225,3 +5215,7 @@   , sdocImpredicativeTypes          = xopt LangExt.ImpredicativeTypes dflags   , sdocDynFlags                    = dflags   }++-- | Initialize the pretty-printing options using the default user style+initDefaultSDocContext :: DynFlags -> SDocContext+initDefaultSDocContext dflags = initSDocContext dflags (defaultUserStyle dflags)
compiler/GHC/Driver/Session.hs-boot view
@@ -1,14 +1,15 @@ module GHC.Driver.Session where -import GhcPrelude+import GHC.Prelude import GHC.Platform-import {-# SOURCE #-} Outputable+import {-# SOURCE #-} GHC.Utils.Outputable+import {-# SOURCE #-} GHC.Unit.State  data DynFlags  targetPlatform           :: DynFlags -> Platform pprUserLength            :: DynFlags -> Int-pprCols                  :: DynFlags -> Int+pkgState                 :: DynFlags -> PackageState unsafeGlobalDynFlags     :: DynFlags hasPprDebug              :: DynFlags -> Bool hasNoDebugOutput         :: DynFlags -> Bool
compiler/GHC/Driver/Types.hs view
@@ -147,12 +147,19 @@          -- * COMPLETE signature         CompleteMatch(..), CompleteMatchMap,-        mkCompleteMatchMap, extendCompleteMatchMap+        mkCompleteMatchMap, extendCompleteMatchMap,++        -- * Exstensible Iface fields+        ExtensibleFields(..), FieldName,+        emptyExtensibleFields,+        readField, readIfaceField, readIfaceFieldWith,+        writeField, writeIfaceField, writeIfaceFieldWith,+        deleteField, deleteIfaceField,     ) where  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.ByteCode.Types import GHC.Runtime.Eval.Types ( Resume )@@ -163,7 +170,7 @@ import GHC.Hs import GHC.Types.Name.Reader import GHC.Types.Avail-import GHC.Types.Module+import GHC.Unit import GHC.Core.InstEnv ( InstEnv, ClsInst, identicalClsInstHead ) import GHC.Core.FamInstEnv import GHC.Core         ( CoreProgram, RuleBase, CoreRule )@@ -175,7 +182,7 @@ import GHC.Types.Id.Info ( IdDetails(..), RecSelParent(..)) import GHC.Core.Type -import ApiAnnotation    ( ApiAnns )+import GHC.Parser.Annotation    ( ApiAnns ) import GHC.Types.Annotations ( Annotation, AnnEnv, mkAnnEnv, plusAnnEnv ) import GHC.Core.Class import GHC.Core.TyCon@@ -183,9 +190,8 @@ import GHC.Core.ConLike import GHC.Core.DataCon import GHC.Core.PatSyn-import PrelNames        ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule )-import TysWiredIn-import GHC.Driver.Packages hiding  ( Version(..) )+import GHC.Builtin.Names ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule )+import GHC.Builtin.Types import GHC.Driver.CmdLine import GHC.Driver.Session import GHC.Runtime.Linker.Types ( DynLinker, Linkable(..), Unlinked(..), SptEntry(..) )@@ -195,30 +201,32 @@ import qualified GHC.Driver.Phases as Phase import GHC.Types.Basic import GHC.Iface.Syntax-import Maybes-import Outputable+import GHC.Data.Maybe+import GHC.Utils.Outputable import GHC.Types.SrcLoc import GHC.Types.Unique import GHC.Types.Unique.DFM-import FastString-import StringBuffer     ( StringBuffer )-import Fingerprint-import MonadUtils-import Bag-import Binary-import ErrUtils+import GHC.Data.FastString+import GHC.Data.StringBuffer ( StringBuffer )+import GHC.Utils.Fingerprint+import GHC.Utils.Monad+import GHC.Data.Bag+import GHC.Utils.Binary+import GHC.Utils.Error import GHC.Types.Name.Cache import GHC.Platform-import Util+import GHC.Utils.Misc import GHC.Types.Unique.DSet import GHC.Serialized   ( Serialized ) import qualified GHC.LanguageExtensions as LangExt  import Foreign-import Control.Monad    ( guard, liftM, ap )+import Control.Monad    ( guard, liftM, ap, forM, forM_, replicateM ) import Data.IORef+import Data.Map         ( Map )+import qualified Data.Map as Map import Data.Time-import Exception+import GHC.Utils.Exception import System.FilePath import Control.DeepSeq import Control.Monad.Trans.Reader@@ -467,8 +475,8 @@          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]+                -- the 'IfGblEnv'. See 'GHC.Tc.Utils.tcg_type_env_var' for+                -- 'GHC.Tc.Utils.TcGblEnv'.  See also Note [hsc_type_env_var hack]          , hsc_interp :: Maybe Interp                 -- ^ target code interpreter (if any) to use for TH and GHCi.@@ -863,8 +871,8 @@  data InstalledFindResult   = InstalledFound ModLocation InstalledModule-  | InstalledNoPackage InstalledUnitId-  | InstalledNotFound [FilePath] (Maybe InstalledUnitId)+  | InstalledNoPackage UnitId+  | InstalledNotFound [FilePath] (Maybe UnitId)  -- | The result of searching for an imported module. --@@ -874,29 +882,29 @@ data FindResult   = Found ModLocation Module         -- ^ The module was found-  | NoPackage UnitId-        -- ^ The requested package was not found+  | NoPackage Unit+        -- ^ The requested unit was not found   | FoundMultiple [(Module, ModuleOrigin)]         -- ^ _Error_: both in multiple packages          -- | Not found   | NotFound-      { fr_paths       :: [FilePath]       -- Places where I looked+      { 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_pkg         :: Maybe Unit       -- ^ Just p => module is in this unit's+                                           --   manifest, but couldn't find the+                                           --   .hi file -      , fr_mods_hidden :: [UnitId]      -- Module is in these packages,+      , fr_mods_hidden :: [Unit]           -- ^ Module is in these units,                                            --   but the *module* is hidden -      , fr_pkgs_hidden :: [UnitId]      -- Module is in these packages,-                                           --   but the *package* is hidden+      , fr_pkgs_hidden :: [Unit]           -- ^ Module is in these units,+                                           --   but the *unit* is hidden -        -- Modules are in these packages, but it is unusable-      , fr_unusables   :: [(UnitId, UnusablePackageReason)]+        -- | Module is in these units, but it is unusable+      , fr_unusables   :: [(Unit, UnusablePackageReason)] -      , fr_suggestions :: [ModuleSuggestion] -- Possible mis-spelled modules+      , fr_suggestions :: [ModuleSuggestion] -- ^ Possible mis-spelled modules       }  {-@@ -1090,9 +1098,17 @@         mi_arg_docs :: ArgDocMap,                 -- ^ Docs on arguments. -        mi_final_exts :: !(IfaceBackendExts phase)+        mi_final_exts :: !(IfaceBackendExts phase),                 -- ^ Either `()` or `ModIfaceBackend` for                 -- a fully instantiated interface.++        mi_ext_fields :: ExtensibleFields+                -- ^ Additional optional fields, where the Map key represents+                -- the field name, resulting in a (size, serialized data) pair.+                -- Because the data is intended to be serialized through the+                -- internal `Binary` class (increasing compatibility with types+                -- using `Name` and `FastString`, such as HIE), this format is+                -- chosen over `ByteString`s.      }  -- | Old-style accessor for whether or not the ModIface came from an hs-boot@@ -1117,11 +1133,11 @@ -- 'ModIface' depends on. mi_free_holes :: ModIface -> UniqDSet ModuleName mi_free_holes iface =-  case splitModuleInsts (mi_module iface) of+  case getModuleInstantiation (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))+        -> renameFreeHoles (mkUniqDSet cands) (instUnitInsts (moduleUnit indef))     _   -> emptyUniqDSet   where     cands = map fst (dep_mods (mi_deps iface))@@ -1164,6 +1180,9 @@                  mi_doc_hdr   = doc_hdr,                  mi_decl_docs = decl_docs,                  mi_arg_docs  = arg_docs,+                 mi_ext_fields = _ext_fields, -- Don't `put_` this in the instance so we+                                              -- can deal with it's pointer in the header+                                              -- when we write the actual file                  mi_final_exts = ModIfaceBackend {                    mi_iface_hash = iface_hash,                    mi_mod_hash = mod_hash,@@ -1264,6 +1283,8 @@                  mi_doc_hdr     = doc_hdr,                  mi_decl_docs   = decl_docs,                  mi_arg_docs    = arg_docs,+                 mi_ext_fields  = emptyExtensibleFields, -- placeholder because this is dealt+                                                         -- with specially when the file is read                  mi_final_exts = ModIfaceBackend {                    mi_iface_hash = iface_hash,                    mi_mod_hash = mod_hash,@@ -1307,7 +1328,9 @@                mi_doc_hdr     = Nothing,                mi_decl_docs   = emptyDeclDocMap,                mi_arg_docs    = emptyArgDocMap,-               mi_final_exts        = () }+               mi_final_exts  = (),+               mi_ext_fields  = emptyExtensibleFields+             }  emptyFullModIface :: Module -> ModIface emptyFullModIface mod =@@ -1493,14 +1516,14 @@          cg_foreign   :: !ForeignStubs,   -- ^ Foreign export stubs         cg_foreign_files :: ![(ForeignSrcLang, FilePath)],-        cg_dep_pkgs  :: ![InstalledUnitId], -- ^ Dependent packages, used to+        cg_dep_pkgs  :: ![UnitId], -- ^ 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+                -- See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable     }  -----------------------------------@@ -1537,7 +1560,7 @@    ...etc... with each bunch of declarations using a new module, all sharing a common package 'interactive' (see Module.interactiveUnitId, and-PrelNames.mkInteractiveModule).+GHC.Builtin.Names.mkInteractiveModule).  This scheme deals well with shadowing.  For example: @@ -1624,7 +1647,7 @@     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.+    GHC.Tc.Module.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@@ -1826,7 +1849,7 @@ -- Set the 'thisPackage' DynFlag to 'interactive' setInteractivePackage hsc_env    = hsc_env { hsc_dflags = (hsc_dflags hsc_env)-                { thisInstalledUnitId = toInstalledUnitId interactiveUnitId } }+                { thisUnitId = toUnitId interactiveUnitId } }  setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext setInteractivePrintName ic n = ic{ic_int_print = n}@@ -1920,8 +1943,8 @@ 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.+instantiated units, 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@@ -1987,10 +2010,10 @@ -- is only one exposed package which exports this module, don't qualify. mkQualModule :: DynFlags -> QueryQualifyModule mkQualModule dflags mod-     | moduleUnitId mod == thisPackage dflags = False+     | moduleUnit mod == thisPackage dflags = False       | [(_, pkgconfig)] <- lookup,-       packageConfigId pkgconfig == moduleUnitId mod+       mkUnit pkgconfig == moduleUnit 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@@ -2014,7 +2037,7 @@      = False      | otherwise      = True-     where mb_pkgid = fmap sourcePackageId (lookupUnit dflags uid)+     where mb_pkgid = fmap unitPackageId (lookupUnit dflags uid)  -- | A function which only qualifies package names if necessary; but -- qualifies all other identifiers.@@ -2485,7 +2508,7 @@                         -- I.e. modules that this one imports, or that are in the                         --      dep_mods of those directly-imported modules -         , dep_pkgs   :: [(InstalledUnitId, Bool)]+         , dep_pkgs   :: [(UnitId, 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@@ -2515,7 +2538,7 @@          }   deriving( Eq )         -- Equality used only for old/new comparison in GHC.Iface.Recomp.addFingerprints-        -- See 'TcRnTypes.ImportAvails' for details on dependencies.+        -- See 'GHC.Tc.Utils.ImportAvails' for details on dependencies.  instance Binary Dependencies where     put_ bh deps = do put_ bh (dep_mods deps)@@ -2681,7 +2704,7 @@                 --                 -- 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'+                -- direct from 'GHC.Tc.Utils.imp_dep_mods'          eps_PIT :: !PackageIfaceTable,                 -- ^ The 'ModIface's for modules in external packages@@ -2908,7 +2931,7 @@      }  ms_installed_mod :: ModSummary -> InstalledModule-ms_installed_mod = fst . splitModuleInsts . ms_mod+ms_installed_mod = fst . getModuleInstantiation . ms_mod  ms_mod_name :: ModSummary -> ModuleName ms_mod_name = moduleName . ms_mod@@ -3130,7 +3153,7 @@        -- 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+    -- See note [Api annotations] in GHC.Parser.Annotation   }  {-@@ -3256,7 +3279,7 @@ 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+Also see Note [Typechecking Complete Matches] in GHC.Tc.Gen.Bind for a more detailed explanation for how GHC ensures that all the conlikes in a COMPLETE set are consistent. -}@@ -3279,7 +3302,105 @@ -- 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) =+                f13 f14 f15 f16 f17 f18 f19 f20 f21 f22 f23 f24) =     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+    `seq` rnf f24++{-+************************************************************************+*                                                                      *+\subsection{Extensible Iface Fields}+*                                                                      *+************************************************************************+-}++type FieldName = String++newtype ExtensibleFields = ExtensibleFields { getExtensibleFields :: (Map FieldName BinData) }++instance Binary ExtensibleFields where+  put_ bh (ExtensibleFields fs) = do+    put_ bh (Map.size fs :: Int)++    -- Put the names of each field, and reserve a space+    -- for a payload pointer after each name:+    header_entries <- forM (Map.toList fs) $ \(name, dat) -> do+      put_ bh name+      field_p_p <- tellBin bh+      put_ bh field_p_p+      return (field_p_p, dat)++    -- Now put the payloads and use the reserved space+    -- to point to the start of each payload:+    forM_ header_entries $ \(field_p_p, dat) -> do+      field_p <- tellBin bh+      putAt bh field_p_p field_p+      seekBin bh field_p+      put_ bh dat++  get bh = do+    n <- get bh :: IO Int++    -- Get the names and field pointers:+    header_entries <- replicateM n $ do+      (,) <$> get bh <*> get bh++    -- Seek to and get each field's payload:+    fields <- forM header_entries $ \(name, field_p) -> do+      seekBin bh field_p+      dat <- get bh+      return (name, dat)++    return . ExtensibleFields . Map.fromList $ fields++instance NFData ExtensibleFields where+  rnf (ExtensibleFields fs) = rnf fs++emptyExtensibleFields :: ExtensibleFields+emptyExtensibleFields = ExtensibleFields Map.empty++--------------------------------------------------------------------------------+-- | Reading++readIfaceField :: Binary a => FieldName -> ModIface -> IO (Maybe a)+readIfaceField name = readIfaceFieldWith name get++readField :: Binary a => FieldName -> ExtensibleFields -> IO (Maybe a)+readField name = readFieldWith name get++readIfaceFieldWith :: FieldName -> (BinHandle -> IO a) -> ModIface -> IO (Maybe a)+readIfaceFieldWith name read iface = readFieldWith name read (mi_ext_fields iface)++readFieldWith :: FieldName -> (BinHandle -> IO a) -> ExtensibleFields -> IO (Maybe a)+readFieldWith name read fields = sequence $ ((read =<<) . dataHandle) <$>+  Map.lookup name (getExtensibleFields fields)++--------------------------------------------------------------------------------+-- | Writing++writeIfaceField :: Binary a => FieldName -> a -> ModIface -> IO ModIface+writeIfaceField name x = writeIfaceFieldWith name (`put_` x)++writeField :: Binary a => FieldName -> a -> ExtensibleFields -> IO ExtensibleFields+writeField name x = writeFieldWith name (`put_` x)++writeIfaceFieldWith :: FieldName -> (BinHandle -> IO ()) -> ModIface -> IO ModIface+writeIfaceFieldWith name write iface = do+  fields <- writeFieldWith name write (mi_ext_fields iface)+  return iface{ mi_ext_fields = fields }++writeFieldWith :: FieldName -> (BinHandle -> IO ()) -> ExtensibleFields -> IO ExtensibleFields+writeFieldWith name write fields = do+  bh <- openBinMem (1024 * 1024)+  write bh+  --+  bd <- handleData bh+  return $ ExtensibleFields (Map.insert name bd $ getExtensibleFields fields)++deleteField :: FieldName -> ExtensibleFields -> ExtensibleFields+deleteField name (ExtensibleFields fs) = ExtensibleFields $ Map.delete name fs++deleteIfaceField :: FieldName -> ModIface -> ModIface+deleteIfaceField name iface = iface { mi_ext_fields = deleteField name (mi_ext_fields iface) }
compiler/GHC/Driver/Ways.hs view
@@ -37,7 +37,7 @@    ) where -import GhcPrelude+import GHC.Prelude import GHC.Platform import GHC.Driver.Flags
compiler/GHC/Hs.hs view
@@ -36,7 +36,7 @@ ) where  -- friends:-import GhcPrelude+import GHC.Prelude  import GHC.Hs.Decls import GHC.Hs.Binds@@ -52,9 +52,9 @@ import GHC.Hs.Instances () -- For Data instances  -- others:-import Outputable+import GHC.Utils.Outputable import GHC.Types.SrcLoc-import GHC.Types.Module ( ModuleName )+import GHC.Unit.Module ( ModuleName )  -- libraries: import Data.Data hiding ( Fixity )@@ -80,7 +80,7 @@         --  - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnOpen'         --                                   ,'ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation       hsmodImports :: [LImportDecl GhcPs],         -- ^ We snaffle interesting stuff out of the imported interfaces early         -- on, adding that info to TyDecls/etc; so this list is often empty,@@ -94,14 +94,14 @@         --                                   ,'ApiAnnotation.AnnClose'         -- -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation       hsmodHaddockModHeader :: Maybe LHsDocString         -- ^ Haddock module info and description, unparsed         --         --  - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnOpen'         --                                   ,'ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation    }      -- ^ 'ApiAnnotation.AnnKeywordId's      --@@ -111,7 +111,7 @@      --    'ApiAnnotation.AnnClose' for explicit braces and semi around      --    hsmodImports,hsmodDecls if this style is used. -     -- For details on above see note [Api annotations] in ApiAnnotation+     -- For details on above see note [Api annotations] in GHC.Parser.Annotation  deriving instance Data HsModule
compiler/GHC/Hs/Binds.hs view
@@ -23,7 +23,7 @@  module GHC.Hs.Binds where -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Hs.Expr ( pprExpr, LHsExpr,                                     MatchGroup, pprFunBind,@@ -33,16 +33,16 @@ import GHC.Hs.Extension import GHC.Hs.Types import GHC.Core-import TcEvidence+import GHC.Tc.Types.Evidence import GHC.Core.Type import GHC.Types.Name.Set import GHC.Types.Basic-import Outputable+import GHC.Utils.Outputable import GHC.Types.SrcLoc as SrcLoc import GHC.Types.Var-import Bag-import FastString-import BooleanFormula (LBooleanFormula)+import GHC.Data.Bag+import GHC.Data.FastString+import GHC.Data.BooleanFormula (LBooleanFormula)  import Data.Data hiding ( Fixity ) import Data.List hiding ( foldr )@@ -94,7 +94,7 @@       -- ^ Empty Local Bindings    | XHsLocalBindsLR-        (XXHsLocalBindsLR idL idR)+        !(XXHsLocalBindsLR idL idR)  type instance XHsValBinds      (GhcPass pL) (GhcPass pR) = NoExtField type instance XHsIPBinds       (GhcPass pL) (GhcPass pR) = NoExtField@@ -126,7 +126,7 @@     -- After renaming RHS; idR can be Name or Id Dependency analysed,     -- later bindings in the list may depend on earlier ones.   | XValBindsLR-      (XXValBindsLR idL idR)+      !(XXValBindsLR idL idR)  -- --------------------------------------------------------------------- -- Deal with ValBindsOut@@ -198,7 +198,7 @@     -- and variables                          @f = \x -> e@     -- and strict variables                   @!x = x + 1@     ---    -- Reason 1: Special case for type inference: see 'TcBinds.tcMonoBinds'.+    -- Reason 1: Special case for type inference: see 'GHC.Tc.Gen.Bind.tcMonoBinds'.     --     -- Reason 2: Instance decls can only have FunBinds, which is convenient.     --           If you change this, you'll need to change e.g. rnMethodBinds@@ -218,7 +218,7 @@     --  - 'ApiAnnotation.AnnEqual','ApiAnnotation.AnnWhere',     --    'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose', -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation     FunBind {          fun_ext :: XFunBind idL idR,@@ -259,7 +259,7 @@   --       'ApiAnnotation.AnnEqual','ApiAnnotation.AnnWhere',   --       'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose', -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | PatBind {         pat_ext    :: XPatBind idL idR, -- ^ See Note [Bind free vars]         pat_lhs    :: LPat idL,@@ -291,7 +291,7 @@         abs_exports :: [ABExport idL],          -- | Evidence bindings-        -- Why a list? See TcInstDcls+        -- Why a list? See GHC.Tc.TyCl.Instance         -- Note [Typechecking plan for instance declarations]         abs_ev_binds :: [TcEvBinds], @@ -310,9 +310,9 @@         --          'ApiAnnotation.AnnWhere'         --          'ApiAnnotation.AnnOpen' @'{'@,'ApiAnnotation.AnnClose' @'}'@ -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation -  | XHsBindsLR (XXHsBindsLR idL idR)+  | XHsBindsLR !(XXHsBindsLR idL idR)  data NPatBindTc = NPatBindTc {      pat_fvs :: NameSet, -- ^ Free variables@@ -354,7 +354,7 @@              -- Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly         , abe_prags     :: TcSpecPrags  -- ^ SPECIALISE pragmas         }-   | XABExport (XXABExport p)+   | XABExport !(XXABExport p)  type instance XABE       (GhcPass p) = NoExtField type instance XXABExport (GhcPass p) = NoExtCon@@ -365,7 +365,7 @@ --             'ApiAnnotation.AnnWhere','ApiAnnotation.AnnOpen' @'{'@, --             'ApiAnnotation.AnnClose' @'}'@, --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Pattern Synonym binding data PatSynBind idL idR@@ -377,7 +377,7 @@           psb_def  :: LPat idR,                -- ^ Right-hand side           psb_dir  :: HsPatSynDir idR          -- ^ Directionality      }-   | XPatSynBind (XXPatSynBind idL idR)+   | XPatSynBind !(XXPatSynBind idL idR)  type instance XPSB         (GhcPass idL) GhcPs = NoExtField type instance XPSB         (GhcPass idL) GhcRn = NameSet@@ -590,7 +590,7 @@ The abe_wrap field deals with impedance-matching between     (/\a b. case tup a b of { (f,g) -> f }) and the thing we really want, which may have fewer type-variables.  The action happens in TcBinds.mkExport.+variables.  The action happens in GHC.Tc.Gen.Bind.mkExport.  Note [Bind free vars] ~~~~~~~~~~~~~~~~~~~~~@@ -598,14 +598,14 @@ of the definition.  It is used for the following purposes  a) Dependency analysis prior to type checking-    (see TcBinds.tc_group)+    (see GHC.Tc.Gen.Bind.tc_group)  b) Deciding whether we can do generalisation of the binding-    (see TcBinds.decideGeneralisationPlan)+    (see GHC.Tc.Gen.Bind.decideGeneralisationPlan)  c) Deciding whether the binding can be used in static forms-    (see TcExpr.checkClosedInStaticForm for the HsStatic case and-     TcBinds.isClosedBndrGroup).+    (see GHC.Tc.Gen.Expr.checkClosedInStaticForm for the HsStatic case and+     GHC.Tc.Gen.Bind.isClosedBndrGroup).  Specifically, @@ -623,7 +623,6 @@   ppr (HsValBinds _ bs)   = ppr bs   ppr (HsIPBinds _ bs)    = ppr bs   ppr (EmptyLocalBinds _) = empty-  ppr (XHsLocalBindsLR x) = ppr x  instance (OutputableBndrId pl, OutputableBndrId pr)         => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr)) where@@ -750,14 +749,12 @@                , 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)            , pprIfTc @p $ nest 2 (text "wrap:" <+> ppr wrap) ]-  ppr (XABExport x) = ppr x  instance (OutputableBndrId l, OutputableBndrId r,          Outputable (XXPatSynBind (GhcPass l) (GhcPass r)))@@ -780,7 +777,6 @@           ImplicitBidirectional    -> ppr_simple equals           ExplicitBidirectional mg -> ppr_simple (text "<-") <+> ptext (sLit "where") $$                                       (nest 2 $ pprFunBind mg)-  ppr (XPatSynBind x) = ppr x  pprTicks :: SDoc -> SDoc -> SDoc -- Print stuff about ticks only when -dppr-debug is on, to avoid@@ -807,7 +803,7 @@         [LIPBind id]         -- TcEvBinds       -- Only in typechecker output; binds         --                 -- uses of the implicit parameters-  | XHsIPBinds (XXHsIPBinds id)+  | XHsIPBinds !(XXHsIPBinds id)  type instance XIPBinds       GhcPs = NoExtField type instance XIPBinds       GhcRn = NoExtField@@ -819,18 +815,16 @@  isEmptyIPBindsPR :: HsIPBinds (GhcPass p) -> Bool isEmptyIPBindsPR (IPBinds _ is) = null is-isEmptyIPBindsPR (XHsIPBinds _) = True  isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool isEmptyIPBindsTc (IPBinds ds is) = null is && isEmptyTcEvBinds ds-isEmptyIPBindsTc (XHsIPBinds _) = True  -- | Located Implicit Parameter Binding type LIPBind id = Located (IPBind id) -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a --   list --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Implicit parameter bindings. --@@ -841,13 +835,13 @@ -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnEqual' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data IPBind id   = IPBind         (XCIPBind id)         (Either (Located HsIPName) (IdP id))         (LHsExpr id)-  | XIPBind (XXIPBind id)+  | XIPBind !(XXIPBind id)  type instance XCIPBind    (GhcPass p) = NoExtField type instance XXIPBind    (GhcPass p) = NoExtCon@@ -856,14 +850,12 @@        => Outputable (HsIPBinds (GhcPass p)) where   ppr (IPBinds ds bs) = pprDeeperList vcat (map ppr bs)                         $$ whenPprDebug (pprIfTc @p $ ppr ds)-  ppr (XHsIPBinds x) = ppr x  instance OutputableBndrId p => Outputable (IPBind (GhcPass p)) where   ppr (IPBind _ lr rhs) = name <+> equals <+> pprExpr (unLoc rhs)     where name = case lr of                    Left (L _ ip) -> pprBndr LetBind ip                    Right     id  -> pprBndr LetBind id-  ppr (XIPBind x) = ppr x  {- ************************************************************************@@ -898,7 +890,7 @@       --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon',       --          'ApiAnnotation.AnnComma' -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation     TypeSig        (XTypeSig pass)        [Located (IdP pass)]  -- LHS of the signature; e.g.  f,g,h :: blah@@ -912,7 +904,7 @@       --           'ApiAnnotation.AnnDcolon','ApiAnnotation.AnnForall'       --           'ApiAnnotation.AnnDot','ApiAnnotation.AnnDarrow' -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass)       -- P :: forall a b. Req => Prov => ty @@ -943,7 +935,7 @@         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnInfix',         --           'ApiAnnotation.AnnVal' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | FixSig (XFixSig pass) (FixitySig pass)          -- | An inline pragma@@ -956,7 +948,7 @@         --       'ApiAnnotation.AnnVal','ApiAnnotation.AnnTilde',         --       'ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | InlineSig   (XInlineSig pass)                 (Located (IdP pass)) -- Function name                 InlinePragma         -- Never defaultInlinePragma@@ -972,7 +964,7 @@         --      'ApiAnnotation.AnnClose' @']'@ and @'\#-}'@,         --      'ApiAnnotation.AnnDcolon' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | SpecSig     (XSpecSig pass)                 (Located (IdP pass)) -- Specialise a function or datatype  ...                 [LHsSigType pass]  -- ... to these types@@ -990,7 +982,7 @@         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',         --      'ApiAnnotation.AnnInstance','ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)                   -- Note [Pragma source text] in GHC.Types.Basic @@ -1002,7 +994,7 @@         --      'ApiAnnotation.AnnVbar','ApiAnnotation.AnnComma',         --      'ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | MinimalSig (XMinimalSig pass)                SourceText (LBooleanFormula (Located (IdP pass)))                -- Note [Pragma source text] in GHC.Types.Basic@@ -1030,7 +1022,7 @@                      SourceText                      (Located [Located (IdP pass)])                      (Maybe (Located (IdP pass)))-  | XSig (XXSig pass)+  | XSig !(XXSig pass)  type instance XTypeSig          (GhcPass p) = NoExtField type instance XPatSynSig        (GhcPass p) = NoExtField@@ -1050,7 +1042,7 @@  -- | Fixity Signature data FixitySig pass = FixitySig (XFixitySig pass) [Located (IdP pass)] Fixity-                    | XFixitySig (XXFixitySig pass)+                    | XFixitySig !(XXFixitySig pass)  type instance XFixitySig  (GhcPass p) = NoExtField type instance XXFixitySig (GhcPass p) = NoExtCon@@ -1190,14 +1182,12 @@         <+> opt_sig)   where     opt_sig = maybe empty ((\t -> dcolon <+> ppr t) . unLoc) mty-ppr_sig (XSig x) = ppr x  instance OutputableBndrId p        => Outputable (FixitySig (GhcPass p)) where   ppr (FixitySig _ names fixity) = sep [ppr fixity, pprops]     where       pprops = hsep $ punctuate comma (map (pprInfixOcc . unLoc) names)-  ppr (XFixitySig x) = ppr x  pragBrackets :: SDoc -> SDoc pragBrackets doc = text "{-#" <+> doc <+> text "#-}"
compiler/GHC/Hs/Decls.hs view
@@ -94,7 +94,7 @@     ) where  -- friends:-import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Hs.Expr( HsExpr, HsSplice, pprExpr,                                    pprSpliceDecl )@@ -112,13 +112,13 @@  -- others: import GHC.Core.Class-import Outputable-import Util+import GHC.Utils.Outputable+import GHC.Utils.Misc import GHC.Types.SrcLoc import GHC.Core.Type -import Bag-import Maybes+import GHC.Data.Bag+import GHC.Data.Maybe import Data.Data        hiding (TyCon,Fixity, Infix)  {-@@ -135,7 +135,7 @@         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi'         -- --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | A Haskell Declaration data HsDecl p@@ -154,7 +154,7 @@                                                  -- (Includes quasi-quotes)   | DocD       (XDocD p)       (DocDecl)  -- ^ Documentation comment declaration   | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p) -- ^Role annotation declaration-  | XHsDecl    (XXHsDecl p)+  | XHsDecl    !(XXHsDecl p)  type instance XTyClD      (GhcPass _) = NoExtField type instance XInstD      (GhcPass _) = NoExtField@@ -201,7 +201,7 @@ The story for fixity signatures for class methods is made slightly complicated by the fact that they can appear both inside and outside of the class itself, and both forms of fixity signatures are considered top-level. This matters-in `GHC.Rename.Source.rnSrcDecls`, which must create a fixity environment out+in `GHC.Rename.Module.rnSrcDecls`, which must create a fixity environment out of all top-level fixity signatures before doing anything else. Therefore, `rnSrcDecls` must be aware of both (1) and (2) above. The `hsGroupTopLevelFixitySigs` function is responsible for collecting this@@ -248,7 +248,7 @@          hs_docs   :: [LDocDecl]     }-  | XHsGroup (XXHsGroup p)+  | XHsGroup !(XXHsGroup p)  type instance XCHsGroup (GhcPass _) = NoExtField type instance XXHsGroup (GhcPass _) = NoExtCon@@ -281,7 +281,6 @@                 | L _ ClassDecl{tcdSigs = sigs} <- tyClGroupTyClDecls tyclds                 , L loc (FixSig _ sig) <- sigs                 ]-hsGroupTopLevelFixitySigs (XHsGroup nec) = noExtCon nec  appendGroups :: HsGroup (GhcPass p) -> HsGroup (GhcPass p)              -> HsGroup (GhcPass p)@@ -324,7 +323,6 @@         hs_warnds = warnds1 ++ warnds2,         hs_ruleds = rulds1 ++ rulds2,         hs_docs   = docs1  ++ docs2 }-appendGroups _ _ = panic "appendGroups"  instance (OutputableBndrId p) => Outputable (HsDecl (GhcPass p)) where     ppr (TyClD _ dcl)             = ppr dcl@@ -341,7 +339,6 @@     ppr (SpliceD _ dd)            = ppr dd     ppr (DocD _ doc)              = ppr doc     ppr (RoleAnnotD _ ra)         = ppr ra-    ppr (XHsDecl x)               = ppr x  instance (OutputableBndrId p) => Outputable (HsGroup (GhcPass p)) where     ppr (HsGroup { hs_valds  = val_decls,@@ -376,7 +373,6 @@           vcat_mb _    []             = empty           vcat_mb gap (Nothing : ds) = vcat_mb gap ds           vcat_mb gap (Just d  : ds) = gap $$ d $$ vcat_mb blankLine ds-    ppr (XHsGroup x) = ppr x  -- | Located Splice Declaration type LSpliceDecl pass = Located (SpliceDecl pass)@@ -387,7 +383,7 @@         (XSpliceDecl p)         (Located (HsSplice p))         SpliceExplicitFlag-  | XSpliceDecl (XXSpliceDecl p)+  | XSpliceDecl !(XXSpliceDecl p)  type instance XSpliceDecl      (GhcPass _) = NoExtField type instance XXSpliceDecl     (GhcPass _) = NoExtCon@@ -395,7 +391,6 @@ instance OutputableBndrId p        => Outputable (SpliceDecl (GhcPass p)) where    ppr (SpliceDecl _ (L _ e) f) = pprSpliceDecl e f-   ppr (XSpliceDecl x) = ppr x  {- ************************************************************************@@ -457,7 +452,7 @@ In *source-code* class declarations:   - When parsing, every ClassOpSig gets a DefMeth with a suitable RdrName-   This is done by RdrHsSyn.mkClassOpSigDM+   This is done by GHC.Parser.PostProcess.mkClassOpSigDM   - The renamer renames it to a Name @@ -492,7 +487,7 @@  The type checker makes up new source-code instance declarations (e.g. from 'deriving' or generic default methods --- see-TcInstDcls.tcInstDecls1).  So we can't generate the names for+GHC.Tc.TyCl.Instance.tcInstDecls1).  So we can't generate the names for dictionary functions in advance (we don't know how many we need).  On the other hand for interface-file instance declarations, the decl@@ -551,7 +546,7 @@     --             'ApiAnnotation.AnnEqual','ApiAnnotation.AnnRarrow',     --             'ApiAnnotation.AnnVbar' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation     FamDecl { tcdFExt :: XFamDecl pass, tcdFam :: FamilyDecl pass }    | -- | @type@ declaration@@ -559,7 +554,7 @@     --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType',     --             'ApiAnnotation.AnnEqual', -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation     SynDecl { tcdSExt   :: XSynDecl pass          -- ^ Post renameer, FVs             , tcdLName  :: Located (IdP pass)     -- ^ Type constructor             , tcdTyVars :: LHsQTyVars pass        -- ^ Type variables; for an@@ -576,7 +571,7 @@     --              'ApiAnnotation.AnnNewType','ApiAnnotation.AnnDcolon'     --              'ApiAnnotation.AnnWhere', -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation     DataDecl { tcdDExt     :: XDataDecl pass       -- ^ Post renamer, CUSK flag, FVs              , tcdLName    :: Located (IdP pass)   -- ^ Type constructor              , tcdTyVars   :: LHsQTyVars pass      -- ^ Type variables@@ -603,8 +598,8 @@         --                          'ApiAnnotation.AnnComma'         --                          'ApiAnnotation.AnnRarrow' -        -- For details on above see note [Api annotations] in ApiAnnotation-  | XTyClDecl (XXTyClDecl pass)+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XTyClDecl !(XXTyClDecl pass)  type LHsFunDep pass = Located (FunDep (Located (IdP pass))) @@ -707,17 +702,12 @@ tyFamInstDeclLName (TyFamInstDecl { tfid_eqn =                      (HsIB { hsib_body = FamEqn { feqn_tycon = ln }}) })   = ln-tyFamInstDeclLName (TyFamInstDecl (HsIB _ (XFamEqn nec)))-  = noExtCon nec-tyFamInstDeclLName (TyFamInstDecl (XHsImplicitBndrs nec))-  = noExtCon nec  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 (GhcPass p) -> IdP (GhcPass p) tcdName = unLoc . tyClDeclLName@@ -756,8 +746,6 @@   = hsTvbAllKinded tyvars && isJust (hsTyKindSig rhs) hsDeclHasCusk (DataDecl { tcdDExt = DataDeclRn { tcdDataCusk = cusk }}) = cusk hsDeclHasCusk (ClassDecl { tcdTyVars = tyvars }) = hsTvbAllKinded tyvars-hsDeclHasCusk (FamDecl { tcdFam = XFamilyDecl nec }) = noExtCon nec-hsDeclHasCusk (XTyClDecl nec) = noExtCon nec  -- Pretty-printing TyClDecl -- ~~~~~~~~~~~~~~~~~~~~~~~~@@ -793,8 +781,6 @@                     <+> pp_vanilla_decl_head lclas tyvars fixity context                     <+> pprFundeps (map unLoc fds) -    ppr (XTyClDecl x) = ppr x- instance OutputableBndrId p        => Outputable (TyClGroup (GhcPass p)) where   ppr (TyClGroup { group_tyclds = tyclds@@ -808,7 +794,6 @@       ppr tyclds $$       ppr roles $$       ppr instds-  ppr (XTyClGroup x) = ppr x  pp_vanilla_decl_head :: (OutputableBndrId p)    => Located (IdP (GhcPass p))@@ -830,20 +815,14 @@       | otherwise = hsep [ pprPrefixOcc (unLoc thing)                   , hsep (map (ppr.unLoc) (varl:varsr))]     pp_tyvars [] = pprPrefixOcc (unLoc thing)-pp_vanilla_decl_head _ (XLHsQTyVars x) _ _ = ppr x  pprTyClDeclFlavour :: TyClDecl (GhcPass p) -> SDoc pprTyClDeclFlavour (ClassDecl {})   = text "class" pprTyClDeclFlavour (SynDecl {})     = text "type" pprTyClDeclFlavour (FamDecl { tcdFam = FamilyDecl { fdInfo = info }})   = pprFlavour info <+> text "family"-pprTyClDeclFlavour (FamDecl { tcdFam = XFamilyDecl nec })-  = noExtCon nec pprTyClDeclFlavour (DataDecl { tcdDataDefn = HsDataDefn { dd_ND = nd } })   = ppr nd-pprTyClDeclFlavour (DataDecl { tcdDataDefn = XHsDataDefn x })-  = ppr x-pprTyClDeclFlavour (XTyClDecl x) = ppr x   {- Note [CUSKs: complete user-supplied kind signatures]@@ -962,7 +941,7 @@    ones.  See Note [Dependency analysis of type, class, and instance decls]-in GHC.Rename.Source for more info.+in GHC.Rename.Module for more info. -}  -- | Type or Class Group@@ -972,7 +951,7 @@               , group_roles  :: [LRoleAnnotDecl pass]               , group_kisigs :: [LStandaloneKindSig pass]               , group_instds :: [LInstDecl pass] }-  | XTyClGroup (XXTyClGroup pass)+  | XTyClGroup !(XXTyClGroup pass)  type instance XCTyClGroup (GhcPass _) = NoExtField type instance XXTyClGroup (GhcPass _) = NoExtCon@@ -1068,22 +1047,22 @@     NoSig (XNoSig pass)   -- ^ - 'ApiAnnotation.AnnKeywordId' : -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | KindSig  (XCKindSig pass) (LHsKind pass)   -- ^ - 'ApiAnnotation.AnnKeywordId' :   --             'ApiAnnotation.AnnOpenP','ApiAnnotation.AnnDcolon',   --             'ApiAnnotation.AnnCloseP' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | TyVarSig (XTyVarSig pass) (LHsTyVarBndr pass)   -- ^ - 'ApiAnnotation.AnnKeywordId' :   --             'ApiAnnotation.AnnOpenP','ApiAnnotation.AnnDcolon',   --             'ApiAnnotation.AnnCloseP', 'ApiAnnotation.AnnEqual'-  | XFamilyResultSig (XXFamilyResultSig pass)+  | XFamilyResultSig !(XXFamilyResultSig pass) -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation  type instance XNoSig            (GhcPass _) = NoExtField type instance XCKindSig         (GhcPass _) = NoExtField@@ -1106,7 +1085,7 @@   , fdResultSig      :: LFamilyResultSig pass        -- result signature   , fdInjectivityAnn :: Maybe (LInjectivityAnn pass) -- optional injectivity ann   }-  | XFamilyDecl (XXFamilyDecl pass)+  | XFamilyDecl !(XXFamilyDecl pass)   -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType',   --             'ApiAnnotation.AnnData', 'ApiAnnotation.AnnFamily',   --             'ApiAnnotation.AnnWhere', 'ApiAnnotation.AnnOpenP',@@ -1114,7 +1093,7 @@   --             'ApiAnnotation.AnnEqual', 'ApiAnnotation.AnnRarrow',   --             'ApiAnnotation.AnnVbar' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation  type instance XCFamilyDecl    (GhcPass _) = NoExtField type instance XXFamilyDecl    (GhcPass _) = NoExtCon@@ -1136,7 +1115,7 @@   -- ^ - 'ApiAnnotation.AnnKeywordId' :   --             'ApiAnnotation.AnnRarrow', 'ApiAnnotation.AnnVbar' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation  data FamilyInfo pass   = DataFamily@@ -1150,7 +1129,6 @@  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@@ -1162,8 +1140,6 @@   case unLoc bndr of     UserTyVar _ _ -> Nothing     KindedTyVar _ _ ki -> Just ki-    XTyVarBndr nec -> noExtCon nec-famResultKindSignature (XFamilyResultSig nec) = noExtCon nec  -- | Maybe return name of the result type variable resultVariableName :: FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a))@@ -1196,7 +1172,6 @@                 NoSig    _         -> empty                 KindSig  _ kind    -> dcolon <+> ppr kind                 TyVarSig _ tv_bndr -> text "=" <+> ppr tv_bndr-                XFamilyResultSig nec -> noExtCon nec     pp_inj = case mb_inj of                Just (L _ (InjectivityAnn lhs rhs)) ->                  hsep [ vbar, ppr lhs, text "->", hsep (map ppr rhs) ]@@ -1208,7 +1183,6 @@             Nothing   -> text ".."             Just eqns -> vcat $ map (ppr_fam_inst_eqn . unLoc) eqns )       _ -> (empty, empty)-pprFamilyDecl _ (XFamilyDecl nec) = noExtCon nec  pprFlavour :: FamilyInfo pass -> SDoc pprFlavour DataFamily            = text "data"@@ -1257,9 +1231,9 @@                   dd_derivs :: HsDeriving pass  -- ^ Optional 'deriving' clause -             -- For details on above see note [Api annotations] in ApiAnnotation+             -- For details on above see note [Api annotations] in GHC.Parser.Annotation    }-  | XHsDataDefn (XXHsDataDefn pass)+  | XHsDataDefn !(XXHsDataDefn pass)  type instance XCHsDataDefn    (GhcPass _) = NoExtField @@ -1284,7 +1258,7 @@ --       'ApiAnnotation.AnnAnyClass', 'Api.AnnNewtype', --       'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose' data HsDerivingClause pass-  -- See Note [Deriving strategies] in TcDeriv+  -- See Note [Deriving strategies] in GHC.Tc.Deriv   = HsDerivingClause     { deriv_clause_ext :: XCHsDerivingClause pass     , deriv_clause_strategy :: Maybe (LDerivStrategy pass)@@ -1300,7 +1274,7 @@       --       -- should produce a derived instance for @C [a] (T b)@.     }-  | XHsDerivingClause (XXHsDerivingClause pass)+  | XHsDerivingClause !(XXHsDerivingClause pass)  type instance XCHsDerivingClause    (GhcPass _) = NoExtField type instance XXHsDerivingClause    (GhcPass _) = NoExtCon@@ -1327,7 +1301,6 @@           case dcs of             Just (L _ via@ViaStrategy{}) -> (empty, ppr via)             _                            -> (ppDerivStrategy dcs, empty)-  ppr (XHsDerivingClause x) = ppr x  -- | Located Standalone Kind Signature type LStandaloneKindSig pass = Located (StandaloneKindSig pass)@@ -1336,14 +1309,13 @@   = StandaloneKindSig (XStandaloneKindSig pass)       (Located (IdP pass))  -- Why a single binder? See #16754       (LHsSigType pass)     -- Why not LHsSigWcType? See Note [Wildcards in standalone kind signatures]-  | XStandaloneKindSig (XXStandaloneKindSig pass)+  | XStandaloneKindSig !(XXStandaloneKindSig pass)  type instance XStandaloneKindSig (GhcPass p) = NoExtField type instance XXStandaloneKindSig (GhcPass p) = NoExtCon  standaloneKindSigName :: StandaloneKindSig (GhcPass p) -> IdP (GhcPass p) standaloneKindSigName (StandaloneKindSig _ lname _) = unLoc lname-standaloneKindSigName (XStandaloneKindSig nec) = noExtCon nec  {- Note [Wildcards in standalone kind signatures] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1376,7 +1348,7 @@       -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when       --   in a GADT constructor list -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | --@@ -1400,7 +1372,7 @@ --            'ApiAnnotation.AnnDarrow','ApiAnnotation.AnnDarrow', --            'ApiAnnotation.AnnForall','ApiAnnotation.AnnDot' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | data Constructor Declaration data ConDecl pass@@ -1442,7 +1414,7 @@       , con_doc       :: Maybe LHsDocString           -- ^ A possible Haddock comment.       }-  | XConDecl (XXConDecl pass)+  | XConDecl !(XXConDecl pass)  type instance XConDeclGADT (GhcPass _) = NoExtField type instance XConDeclH98  (GhcPass _) = NoExtField@@ -1472,13 +1444,13 @@   so it's hard to split up the arguments until we've done the precedence   resolution (in the renamer). -  So:  - In the parser (RdrHsSyn.mkGadtDecl), we put the whole constr+  So:  - In the parser (GHC.Parser.PostProcess.mkGadtDecl), we put the whole constr          type into the res_ty for a ConDeclGADT for now, and use          PrefixCon []             con_args   = PrefixCon []             con_res_ty = a :*: (b -> (a :*: (b -> (a :+: b)))) -       - In the renamer (GHC.Rename.Source.rnConDecl), we unravel it after+       - In the renamer (GHC.Rename.Module.rnConDecl), we unravel it after          operator fixities are sorted. So we generate. So we end          up with             con_args   = PrefixCon [ a :*: b, a :*: b ]@@ -1492,7 +1464,6 @@ getConNames :: ConDecl (GhcPass p) -> [Located (IdP (GhcPass p))] getConNames ConDeclH98  {con_name  = name}  = [name] getConNames ConDeclGADT {con_names = names} = names-getConNames (XConDecl nec) = noExtCon nec  getConArgs :: ConDecl pass -> HsConDeclDetails pass getConArgs d = con_args d@@ -1529,7 +1500,6 @@                Nothing   -> empty                Just kind -> dcolon <+> ppr kind     pp_derivings (L _ ds) = vcat (map ppr ds)-pp_data_defn _ (XHsDataDefn x) = ppr x  instance OutputableBndrId p        => Outputable (HsDataDefn (GhcPass p)) where@@ -1539,7 +1509,6 @@        => Outputable (StandaloneKindSig (GhcPass p)) where   ppr (StandaloneKindSig _ v ki)     = text "type" <+> pprPrefixOcc (unLoc v) <+> text "::" <+> ppr ki-  ppr (XStandaloneKindSig nec) = noExtCon nec  instance Outputable NewOrData where   ppr NewType  = text "newtype"@@ -1585,8 +1554,6 @@     ppr_arrow_chain (a:as) = sep (a : map (arrow <+>) as)     ppr_arrow_chain []     = empty -pprConDecl (XConDecl x) = ppr x- ppr_con_names :: (OutputableBndr a) => [Located a] -> SDoc ppr_con_names = pprWithCommas (pprPrefixOcc . unLoc) @@ -1626,7 +1593,7 @@   -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi'   --   when in a list --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Haskell Type Patterns type HsTyPats pass = [LHsTypeArg pass]@@ -1685,7 +1652,7 @@     --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType',     --           'ApiAnnotation.AnnInstance', -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation  ----------------- Data family instances ------------- @@ -1702,7 +1669,7 @@     --           'ApiAnnotation.AnnWhere','ApiAnnotation.AnnOpen',     --           'ApiAnnotation.AnnClose' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation  ----------------- Family instances (common types) ------------- @@ -1731,9 +1698,9 @@        }     -- ^     --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnEqual'-  | XFamEqn (XXFamEqn pass rhs)+  | XFamEqn !(XXFamEqn pass rhs) -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation  type instance XCFamEqn    (GhcPass _) r = NoExtField type instance XXFamEqn    (GhcPass _) r = NoExtCon@@ -1758,15 +1725,15 @@          -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',          --                                    'ApiAnnotation.AnnClose', -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation       }     -- ^     --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnInstance',     --           'ApiAnnotation.AnnWhere',     --           'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose', -    -- For details on above see note [Api annotations] in ApiAnnotation-  | XClsInstDecl (XXClsInstDecl pass)+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XClsInstDecl !(XXClsInstDecl pass)  type instance XCClsInstDecl    (GhcPass _) = NoExtField type instance XXClsInstDecl    (GhcPass _) = NoExtCon@@ -1787,7 +1754,7 @@   | TyFamInstD              -- type family instance       { tfid_ext  :: XTyFamInstD pass       , tfid_inst :: TyFamInstDecl pass }-  | XInstDecl (XXInstDecl pass)+  | XInstDecl !(XXInstDecl pass)  type instance XClsInstD     (GhcPass _) = NoExtField type instance XDataFamInstD (GhcPass _) = NoExtField@@ -1819,8 +1786,6 @@                                             , feqn_fixity = fixity                                             , feqn_rhs    = rhs }})     = pprHsFamInstLHS tycon bndrs pats fixity noLHsContext <+> equals <+> ppr rhs-ppr_fam_inst_eqn (HsIB { hsib_body = XFamEqn x }) = ppr x-ppr_fam_inst_eqn (XHsImplicitBndrs x) = ppr x  instance OutputableBndrId p        => Outputable (DataFamInstDecl (GhcPass p)) where@@ -1840,22 +1805,10 @@               <+> pprHsFamInstLHS tycon bndrs pats fixity ctxt                   -- pp_data_defn pretty-prints the kind sig. See #14817. -pprDataFamInstDecl _ (DataFamInstDecl (HsIB _ (XFamEqn x)))-  = ppr x-pprDataFamInstDecl _ (DataFamInstDecl (XHsImplicitBndrs x))-  = ppr x- pprDataFamInstFlavour :: DataFamInstDecl (GhcPass p) -> SDoc pprDataFamInstFlavour (DataFamInstDecl { dfid_eqn = HsIB { hsib_body =                         FamEqn { feqn_rhs = HsDataDefn { dd_ND = nd }}}})   = ppr nd-pprDataFamInstFlavour (DataFamInstDecl { dfid_eqn = HsIB { hsib_body =-                        FamEqn { feqn_rhs = XHsDataDefn x}}})-  = ppr x-pprDataFamInstFlavour (DataFamInstDecl (HsIB _ (XFamEqn x)))-  = ppr x-pprDataFamInstFlavour (DataFamInstDecl (XHsImplicitBndrs x))-  = ppr x  pprHsFamInstLHS :: (OutputableBndrId p)    => IdP (GhcPass p)@@ -1897,7 +1850,6 @@       where         top_matter = text "instance" <+> ppOverlapPragma mbOverlap                                              <+> ppr inst_ty-    ppr (XClsInstDecl x) = ppr x  ppDerivStrategy :: OutputableBndrId p                 => Maybe (LDerivStrategy (GhcPass p)) -> SDoc@@ -1924,7 +1876,6 @@     ppr (ClsInstD     { cid_inst  = decl }) = ppr decl     ppr (TyFamInstD   { tfid_inst = decl }) = ppr decl     ppr (DataFamInstD { dfid_inst = decl }) = ppr decl-    ppr (XInstDecl x) = ppr x  -- Extract the declarations of associated data types from an instance @@ -1932,12 +1883,11 @@ instDeclDataFamInsts inst_decls   = concatMap do_one inst_decls   where+    do_one :: LInstDecl (GhcPass p) -> [DataFamInstDecl (GhcPass p)]     do_one (L _ (ClsInstD { cid_inst = ClsInstDecl { cid_datafam_insts = fam_insts } }))       = map unLoc fam_insts     do_one (L _ (DataFamInstD { dfid_inst = fam_inst }))      = [fam_inst]     do_one (L _ (TyFamInstD {}))                              = []-    do_one (L _ (ClsInstD _ (XClsInstDecl nec))) = noExtCon nec-    do_one (L _ (XInstDecl nec))                 = noExtCon nec  {- ************************************************************************@@ -1963,7 +1913,7 @@           --           -- Which signifies that the context should be inferred. -          -- See Note [Inferring the instance context] in TcDerivInfer.+          -- See Note [Inferring the instance context] in GHC.Tc.Deriv.Infer.          , deriv_strategy     :: Maybe (LDerivStrategy pass)         , deriv_overlap_mode :: Maybe (Located OverlapMode)@@ -1972,9 +1922,9 @@          --        'ApiAnnotation.AnnAnyClass', 'Api.AnnNewtype',          --        'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation         }-  | XDerivDecl (XXDerivDecl pass)+  | XDerivDecl !(XXDerivDecl pass)  type instance XCDerivDecl    (GhcPass _) = NoExtField type instance XXDerivDecl    (GhcPass _) = NoExtCon@@ -1989,7 +1939,6 @@                , text "instance"                , ppOverlapPragma o                , ppr ty ]-    ppr (XDerivDecl x) = ppr x  {- ************************************************************************@@ -2004,7 +1953,7 @@  -- | Which technique the user explicitly requested when deriving an instance. data DerivStrategy pass-  -- See Note [Deriving strategies] in TcDeriv+  -- See Note [Deriving strategies] in GHC.Tc.Deriv   = StockStrategy    -- ^ GHC's \"standard\" strategy, which is to implement a                      --   custom instance for the data type. This only works                      --   for certain types that GHC knows about (e.g., 'Eq',@@ -2074,8 +2023,8 @@         -- ^ - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnDefault',         --          'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation-  | XDefaultDecl (XXDefaultDecl pass)+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XDefaultDecl !(XXDefaultDecl pass)  type instance XCDefaultDecl    (GhcPass _) = NoExtField type instance XXDefaultDecl    (GhcPass _) = NoExtCon@@ -2084,7 +2033,6 @@        => Outputable (DefaultDecl (GhcPass p)) where     ppr (DefaultDecl _ tys)       = text "default" <+> parens (interpp'SP tys)-    ppr (XDefaultDecl x) = ppr x  {- ************************************************************************@@ -2121,8 +2069,8 @@         --           'ApiAnnotation.AnnImport','ApiAnnotation.AnnExport',         --           'ApiAnnotation.AnnDcolon' -        -- For details on above see note [Api annotations] in ApiAnnotation-  | XForeignDecl (XXForeignDecl pass)+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XForeignDecl !(XXForeignDecl pass)  {-     In both ForeignImport and ForeignExport:@@ -2196,7 +2144,6 @@   ppr (ForeignExport { fd_name = n, fd_sig_ty = ty, fd_fe = fexport }) =     hang (text "foreign export" <+> ppr fexport <+> ppr n)        2 (dcolon <+> ppr ty)-  ppr (XForeignDecl x) = ppr x  instance Outputable ForeignImport where   ppr (CImport  cconv safety mHeader spec (L _ srcText)) =@@ -2246,7 +2193,7 @@ data RuleDecls pass = HsRules { rds_ext   :: XCRuleDecls pass                               , rds_src   :: SourceText                               , rds_rules :: [LRuleDecl pass] }-  | XRuleDecls (XXRuleDecls pass)+  | XRuleDecls !(XXRuleDecls pass)  type instance XCRuleDecls    (GhcPass _) = NoExtField type instance XXRuleDecls    (GhcPass _) = NoExtCon@@ -2277,7 +2224,7 @@     --           'ApiAnnotation.AnnClose',     --           'ApiAnnotation.AnnForall','ApiAnnotation.AnnDot',     --           'ApiAnnotation.AnnEqual',-  | XRuleDecl (XXRuleDecl pass)+  | XRuleDecl !(XXRuleDecl pass)  data HsRuleRn = HsRuleRn NameSet NameSet -- Free-vars from the LHS and RHS   deriving Data@@ -2298,12 +2245,12 @@ data RuleBndr pass   = RuleBndr (XCRuleBndr pass)  (Located (IdP pass))   | RuleBndrSig (XRuleBndrSig pass) (Located (IdP pass)) (LHsSigWcType pass)-  | XRuleBndr (XXRuleBndr pass)+  | XRuleBndr !(XXRuleBndr pass)         -- ^         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',         --     'ApiAnnotation.AnnDcolon','ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation  type instance XCRuleBndr    (GhcPass _) = NoExtField type instance XRuleBndrSig  (GhcPass _) = NoExtField@@ -2320,7 +2267,6 @@                , rds_rules = rules })     = pprWithSourceText st (text "{-# RULES")           <+> vcat (punctuate semi (map ppr rules)) <+> text "#-}"-  ppr (XRuleDecls x) = ppr x  instance (OutputableBndrId p) => Outputable (RuleDecl (GhcPass p)) where   ppr (HsRule { rd_name = name@@ -2338,12 +2284,10 @@           pp_forall_ty (Just qtvs) = forAllLit <+> fsep (map ppr qtvs) <> dot           pp_forall_tm Nothing | null tms = empty           pp_forall_tm _ = forAllLit <+> fsep (map ppr tms) <> dot-  ppr (XRuleDecl x) = ppr x  instance (OutputableBndrId p) => Outputable (RuleBndr (GhcPass p)) where    ppr (RuleBndr _ name) = ppr name    ppr (RuleBndrSig _ name ty) = parens (ppr name <> dcolon <> ppr ty)-   ppr (XRuleBndr x) = ppr x  {- ************************************************************************@@ -2393,7 +2337,7 @@                                , wd_src      :: SourceText                                , wd_warnings :: [LWarnDecl pass]                                }-  | XWarnDecls (XXWarnDecls pass)+  | XWarnDecls !(XXWarnDecls pass)  type instance XWarnings      (GhcPass _) = NoExtField type instance XXWarnDecls    (GhcPass _) = NoExtCon@@ -2403,7 +2347,7 @@  -- | Warning pragma Declaration data WarnDecl pass = Warning (XWarning pass) [Located (IdP pass)] WarningTxt-                   | XWarnDecl (XXWarnDecl pass)+                   | XWarnDecl !(XXWarnDecl pass)  type instance XWarning      (GhcPass _) = NoExtField type instance XXWarnDecl    (GhcPass _) = NoExtCon@@ -2414,14 +2358,12 @@     ppr (Warnings _ (SourceText src) decls)       = text src <+> vcat (punctuate comma (map ppr decls)) <+> text "#-}"     ppr (Warnings _ NoSourceText _decls) = panic "WarnDecls"-    ppr (XWarnDecls x) = ppr x  instance OutputableBndr (IdP (GhcPass p))        => Outputable (WarnDecl (GhcPass p)) where     ppr (Warning _ thing txt)       = hsep ( punctuate comma (map ppr thing))               <+> ppr txt-    ppr (XWarnDecl x) = ppr x  {- ************************************************************************@@ -2444,8 +2386,8 @@       --           'ApiAnnotation.AnnModule'       --           'ApiAnnotation.AnnClose' -      -- For details on above see note [Api annotations] in ApiAnnotation-  | XAnnDecl (XXAnnDecl pass)+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XAnnDecl !(XXAnnDecl pass)  type instance XHsAnnotation (GhcPass _) = NoExtField type instance XXAnnDecl     (GhcPass _) = NoExtCon@@ -2453,7 +2395,6 @@ instance (OutputableBndrId p) => Outputable (AnnDecl (GhcPass p)) where     ppr (HsAnnotation _ _ provenance expr)       = hsep [text "{-#", pprAnnProvenance provenance, pprExpr (unLoc expr), text "#-}"]-    ppr (XAnnDecl x) = ppr x  -- | Annotation Provenance data AnnProvenance name = ValueAnnProvenance (Located name)@@ -2497,8 +2438,8 @@       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnType',       --           'ApiAnnotation.AnnRole' -      -- For details on above see note [Api annotations] in ApiAnnotation-  | XRoleAnnotDecl (XXRoleAnnotDecl pass)+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XRoleAnnotDecl !(XXRoleAnnotDecl pass)  type instance XCRoleAnnotDecl (GhcPass _) = NoExtField type instance XXRoleAnnotDecl (GhcPass _) = NoExtCon@@ -2511,8 +2452,6 @@     where       pp_role Nothing  = underscore       pp_role (Just r) = ppr r-  ppr (XRoleAnnotDecl x) = ppr x  roleAnnotDeclName :: RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p) roleAnnotDeclName (RoleAnnotDecl _ (L _ name) _) = name-roleAnnotDeclName (XRoleAnnotDecl nec) = noExtCon nec
compiler/GHC/Hs/Doc.hs view
@@ -23,13 +23,13 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import Binary-import Encoding-import FastFunctions+import GHC.Utils.Binary+import GHC.Utils.Encoding+import GHC.Utils.IO.Unsafe import GHC.Types.Name-import Outputable+import GHC.Utils.Outputable as Outputable import GHC.Types.SrcLoc  import Data.ByteString (ByteString)
compiler/GHC/Hs/Dump.hs view
@@ -15,20 +15,20 @@         BlankSrcSpan(..),     ) where -import GhcPrelude+import GHC.Prelude  import Data.Data hiding (Fixity)-import Bag+import GHC.Data.Bag import GHC.Types.Basic-import FastString+import GHC.Data.FastString import GHC.Types.Name.Set import GHC.Types.Name import GHC.Core.DataCon import GHC.Types.SrcLoc import GHC.Hs import GHC.Types.Var-import GHC.Types.Module-import Outputable+import GHC.Unit.Module+import GHC.Utils.Outputable  import qualified Data.ByteString as B
compiler/GHC/Hs/Expr.hs view
@@ -26,7 +26,7 @@ #include "HsVersions.h"  -- friends:-import GhcPrelude+import GHC.Prelude  import GHC.Hs.Decls import GHC.Hs.Pat@@ -36,20 +36,20 @@ import GHC.Hs.Binds  -- others:-import TcEvidence+import GHC.Tc.Types.Evidence import GHC.Core import GHC.Types.Name import GHC.Types.Name.Set import GHC.Types.Basic import GHC.Core.ConLike import GHC.Types.SrcLoc-import Util-import Outputable-import FastString+import GHC.Utils.Misc+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Core.Type-import TysWiredIn (mkTupleStr)-import TcType (TcType)-import {-# SOURCE #-} TcRnTypes (TcLclEnv)+import GHC.Builtin.Types (mkTupleStr)+import GHC.Tc.Utils.TcType (TcType)+import {-# SOURCE #-} GHC.Tc.Types (TcLclEnv)  -- libraries: import Data.Data hiding (Fixity(..))@@ -75,7 +75,7 @@   -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when   --   in a list -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation  ------------------------- -- | Post-Type checking Expression@@ -281,7 +281,7 @@        -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam',        --       'ApiAnnotation.AnnRarrow', -       -- For details on above see note [Api annotations] in ApiAnnotation+       -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p)) -- ^ Lambda-case        --@@ -289,11 +289,13 @@        --           'ApiAnnotation.AnnCase','ApiAnnotation.AnnOpen',        --           'ApiAnnotation.AnnClose' -       -- For details on above see note [Api annotations] in ApiAnnotation+       -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsApp     (XApp p) (LHsExpr p) (LHsExpr p) -- ^ Application -  | HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))  -- ^ Visible type application+  | HsAppType (XAppTypeE p) -- After typechecking: the type argument+              (LHsExpr p)+              (LHsWcType (NoGhcTc p))  -- ^ Visible type application        --        -- Explicit type argument; e.g  f @Int x y        -- NB: Has wildcards, but no implicit quantification@@ -316,7 +318,7 @@   --   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnMinus' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | NegApp      (XNegApp p)                 (LHsExpr p)                 (SyntaxExpr p)@@ -324,7 +326,7 @@   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,   --             'ApiAnnotation.AnnClose' @')'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsPar       (XPar p)                 (LHsExpr p)  -- ^ Parenthesised expr; see Note [Parens in HsSyn] @@ -340,7 +342,7 @@   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',   --         'ApiAnnotation.AnnClose' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   -- Note [ExplicitTuple]   | ExplicitTuple         (XExplicitTuple p)@@ -364,7 +366,7 @@   --       'ApiAnnotation.AnnOf','ApiAnnotation.AnnOpen' @'{'@,   --       'ApiAnnotation.AnnClose' @'}'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsCase      (XCase p)                 (LHsExpr p)                 (MatchGroup p (LHsExpr p))@@ -374,7 +376,7 @@   --       'ApiAnnotation.AnnThen','ApiAnnotation.AnnSemi',   --       'ApiAnnotation.AnnElse', -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsIf        (XIf p)        -- GhcPs: this is a Bool; False <=> do not use                                --  rebindable syntax                 (SyntaxExpr p) -- cond function@@ -389,7 +391,7 @@   -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnIf'   --       'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose', -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsMultiIf   (XMultiIf p) [LGRHS p (LHsExpr p)]    -- | let(rec)@@ -398,7 +400,7 @@   --       'ApiAnnotation.AnnOpen' @'{'@,   --       'ApiAnnotation.AnnClose' @'}'@,'ApiAnnotation.AnnIn' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsLet       (XLet p)                 (LHsLocalBinds p)                 (LHsExpr  p)@@ -408,7 +410,7 @@   --             'ApiAnnotation.AnnVbar',   --             'ApiAnnotation.AnnClose' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsDo        (XDo p)                  -- Type of the whole expression                 (HsStmtContext GhcRn)    -- The parameterisation is unimportant                                          -- because in this context we never use@@ -420,7 +422,7 @@   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@,   --              'ApiAnnotation.AnnClose' @']'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   -- See Note [Empty lists]   | ExplicitList                 (XExplicitList p)  -- Gives type of components of list@@ -433,7 +435,7 @@   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@,   --         'ApiAnnotation.AnnDotdot','ApiAnnotation.AnnClose' @'}'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | RecordCon       { rcon_ext      :: XRecordCon p       , rcon_con_name :: Located (IdP p)    -- The constructor name;@@ -445,7 +447,7 @@   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@,   --         'ApiAnnotation.AnnDotdot','ApiAnnotation.AnnClose' @'}'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | RecordUpd       { rupd_ext  :: XRecordUpd p       , rupd_expr :: LHsExpr p@@ -458,7 +460,7 @@   --   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | ExprWithTySig                 (XExprWithTySig p) @@ -471,14 +473,14 @@   --              'ApiAnnotation.AnnComma','ApiAnnotation.AnnDotdot',   --              'ApiAnnotation.AnnClose' @']'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | ArithSeq                 (XArithSeq p)                 (Maybe (SyntaxExpr p))                                   -- For OverloadedLists, the fromList witness                 (ArithSeqInfo p) -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation    -----------------------------------------------------------   -- MetaHaskell Extensions@@ -487,7 +489,7 @@   --         'ApiAnnotation.AnnOpenE','ApiAnnotation.AnnOpenEQ',   --         'ApiAnnotation.AnnClose','ApiAnnotation.AnnCloseQ' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsBracket    (XBracket p) (HsBracket p)      -- See Note [Pending Splices]@@ -509,7 +511,7 @@   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',   --         'ApiAnnotation.AnnClose' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsSpliceE  (XSpliceE p) (HsSplice p)    -----------------------------------------------------------@@ -520,7 +522,7 @@   --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnProc',   --          'ApiAnnotation.AnnRarrow' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsProc      (XProc p)                 (LPat p)               -- arrow abstraction, proc                 (LHsCmdTop p)          -- body of the abstraction@@ -530,7 +532,7 @@   -- static pointers extension   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnStatic', -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsStatic (XStatic p) -- Free variables of the body              (LHsExpr p)        -- Body @@ -552,7 +554,7 @@   -- Expressions annotated with pragmas, written as {-# ... #-}   | HsPragE (XPragE p) (HsPragE p) (LHsExpr p) -  | XExpr       (XXExpr p) -- Note [Trees that Grow] extension constructor+  | XExpr       !(XXExpr p) -- Note [Trees that Grow] extension constructor   -- | Extra data fields for a 'RecordCon', added by the type checker@@ -599,7 +601,9 @@ type instance XLamCase       (GhcPass _) = NoExtField type instance XApp           (GhcPass _) = NoExtField -type instance XAppTypeE      (GhcPass _) = NoExtField+type instance XAppTypeE      GhcPs = NoExtField+type instance XAppTypeE      GhcRn = NoExtField+type instance XAppTypeE      GhcTc = Type  type instance XOpApp         GhcPs = NoExtField type instance XOpApp         GhcRn = Fixity@@ -681,7 +685,7 @@   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{-\# CORE'@,   --             'ApiAnnotation.AnnVal', 'ApiAnnotation.AnnClose' @'\#-}'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsPragCore  (XCoreAnn p)                 SourceText            -- Note [Pragma source text] in GHC.Types.Basic                 StringLiteral         -- hdaume: core annotation@@ -695,7 +699,7 @@   --       'ApiAnnotation.AnnVal',   --       'ApiAnnotation.AnnClose' @'\#-}'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsPragTick                        -- A pragma introduced tick      (XTickPragma p)      SourceText                       -- Note [Pragma source text] in GHC.Types.Basic@@ -705,7 +709,7 @@         -- Source text for the four integers used in the span.         -- See note [Pragma source text] in GHC.Types.Basic -  | XHsPragE (XXPragE p)+  | XHsPragE !(XXPragE p)  type instance XSCC           (GhcPass _) = NoExtField type instance XCoreAnn       (GhcPass _) = NoExtField@@ -721,13 +725,13 @@ type LHsTupArg id = Located (HsTupArg id) -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Haskell Tuple Argument data HsTupArg id   = Present (XPresent id) (LHsExpr id)     -- ^ The argument   | Missing (XMissing id)    -- ^ The argument is missing, but this is its type-  | XTupArg (XXTupArg id)    -- ^ Note [Trees that Grow] extension point+  | XTupArg !(XXTupArg id)   -- ^ Note [Trees that Grow] extension point  type instance XPresent         (GhcPass _) = NoExtField @@ -836,12 +840,12 @@       Note that the tuple section has *inferred* arguments, while the data      constructor has *specified* ones.-     (See Note [Required, Specified, and Inferred for types] in TcTyClsDecls+     (See Note [Required, Specified, and Inferred for types] in GHC.Tc.TyCl      for background.)  Sadly, the grammar for this is actually ambiguous, and it's only thanks to the preference of a shift in a shift/reduce conflict that the parser works as this-Note details. Search for a reference to this Note in Parser.y for further+Note details. Search for a reference to this Note in GHC.Parser for further explanation.  Note [Empty lists]@@ -853,7 +857,7 @@ Parsing ------- An empty list is parsed by the sysdcon nonterminal. It thus comes to life via-HsVar nilDataCon (defined in TysWiredIn). A freshly-parsed (HsExpr GhcPs) empty list+HsVar nilDataCon (defined in GHC.Builtin.Types). A freshly-parsed (HsExpr GhcPs) empty list is never a ExplicitList.  Renaming@@ -988,7 +992,6 @@     ppr_tup_args []               = []     ppr_tup_args (Present _ e : es) = (ppr_lexpr e <> punc es) : ppr_tup_args es     ppr_tup_args (Missing _   : es) = punc es : ppr_tup_args es-    ppr_tup_args (XTupArg x   : es) = (ppr x <> punc es) : ppr_tup_args es      punc (Present {} : _) = comma <> space     punc (Missing {} : _) = comma@@ -1066,8 +1069,6 @@  ppr_expr (HsProc _ pat (L _ (HsCmdTop _ cmd)))   = hsep [text "proc", ppr pat, ptext (sLit "->"), ppr cmd]-ppr_expr (HsProc _ pat (L _ (XCmdTop x)))-  = hsep [text "proc", ppr pat, ptext (sLit "->"), ppr x]  ppr_expr (HsStatic _ e)   = hsep [text "static", ppr e]@@ -1086,8 +1087,10 @@  ppr_expr (HsRecFld _ f) = ppr f ppr_expr (XExpr x) = case ghcPass @p of+#if __GLASGOW_HASKELL__ < 811   GhcPs -> ppr x   GhcRn -> ppr x+#endif   GhcTc -> case x of     HsWrap co_fn e -> pprHsWrapper co_fn (\parens -> if parens then pprExpr e                                                       else pprExpr e)@@ -1215,8 +1218,12 @@   | hsExprNeedsParens p e = L loc (HsPar noExtField le)   | otherwise             = le -stripParensHsExpr :: LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)-stripParensHsExpr (L _ (HsPar _ e)) = stripParensHsExpr e+stripParensLHsExpr :: LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)+stripParensLHsExpr (L _ (HsPar _ e)) = stripParensLHsExpr e+stripParensLHsExpr e = e++stripParensHsExpr :: HsExpr (GhcPass p) -> HsExpr (GhcPass p)+stripParensHsExpr (HsPar _ (L _ e)) = stripParensHsExpr e stripParensHsExpr e = e  isAtomicHsExpr :: forall p. IsPass p => HsExpr (GhcPass p) -> Bool@@ -1251,7 +1258,6 @@     <+> char '-'     <+> pprWithSourceText s3 (ppr v3) <+> char ':' <+> pprWithSourceText s4 (ppr v4)     <+> text "#-}"-  ppr (XHsPragE x) = noExtCon x  {- ************************************************************************@@ -1272,7 +1278,7 @@   --          'ApiAnnotation.Annrarrowtail','ApiAnnotation.AnnLarrowtail',   --          'ApiAnnotation.AnnRarrowtail' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   = HsCmdArrApp          -- Arrow tail, or arrow application (f -< arg)         (XCmdArrApp id)  -- type of the arrow expressions f,                          -- of the form a t t', where arg :: t@@ -1285,7 +1291,7 @@   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpenB' @'(|'@,   --         'ApiAnnotation.AnnCloseB' @'|)'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | HsCmdArrForm         -- Command formation,  (| e cmd1 .. cmdn |)         (XCmdArrForm id)         (LHsExpr id)     -- The operator.@@ -1306,14 +1312,14 @@        -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam',        --       'ApiAnnotation.AnnRarrow', -       -- For details on above see note [Api annotations] in ApiAnnotation+       -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsCmdPar    (XCmdPar id)                 (LHsCmd id)                     -- parenthesised command     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,     --             'ApiAnnotation.AnnClose' @')'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsCmdCase   (XCmdCase id)                 (LHsExpr id)@@ -1322,8 +1328,16 @@     --       'ApiAnnotation.AnnOf','ApiAnnotation.AnnOpen' @'{'@,     --       'ApiAnnotation.AnnClose' @'}'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation +  | HsCmdLamCase (XCmdLamCase id)+                 (MatchGroup id (LHsCmd id))    -- bodies are HsCmd's+    -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLam',+    --       'ApiAnnotation.AnnCase','ApiAnnotation.AnnOpen' @'{'@,+    --       'ApiAnnotation.AnnClose' @'}'@++    -- For details on above see note [Api annotations] in GHC.Parser.Annotation+   | HsCmdIf     (XCmdIf id)                 (SyntaxExpr id)         -- cond function                 (LHsExpr id)            -- predicate@@ -1334,7 +1348,7 @@     --       'ApiAnnotation.AnnThen','ApiAnnotation.AnnSemi',     --       'ApiAnnotation.AnnElse', -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsCmdLet    (XCmdLet id)                 (LHsLocalBinds id)      -- let(rec)@@ -1343,7 +1357,7 @@     --       'ApiAnnotation.AnnOpen' @'{'@,     --       'ApiAnnotation.AnnClose' @'}'@,'ApiAnnotation.AnnIn' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsCmdDo     (XCmdDo id)                     -- Type of the whole expression                 (Located [CmdLStmt id])@@ -1352,9 +1366,9 @@     --             'ApiAnnotation.AnnVbar',     --             'ApiAnnotation.AnnClose' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation -  | XCmd        (XXCmd id)     -- Note [Trees that Grow] extension point+  | XCmd        !(XXCmd id)     -- Note [Trees that Grow] extension point  type instance XCmdArrApp  GhcPs = NoExtField type instance XCmdArrApp  GhcRn = NoExtField@@ -1365,6 +1379,7 @@ type instance XCmdLam     (GhcPass _) = NoExtField type instance XCmdPar     (GhcPass _) = NoExtField type instance XCmdCase    (GhcPass _) = NoExtField+type instance XCmdLamCase (GhcPass _) = NoExtField type instance XCmdIf      (GhcPass _) = NoExtField type instance XCmdLet     (GhcPass _) = NoExtField @@ -1398,7 +1413,7 @@ data HsCmdTop p   = HsCmdTop (XCmdTop p)              (LHsCmd p)-  | XCmdTop (XXCmdTop p)        -- Note [Trees that Grow] extension point+  | XCmdTop !(XXCmdTop p)        -- Note [Trees that Grow] extension point  data CmdTopTc   = CmdTopTc Type    -- Nested tuple of inputs on the command's stack@@ -1454,6 +1469,9 @@   = sep [ sep [text "case", nest 4 (ppr expr), ptext (sLit "of")],           nest 2 (pprMatches matches) ] +ppr_cmd (HsCmdLamCase _ matches)+  = sep [ text "\\case", nest 2 (pprMatches matches) ]+ ppr_cmd (HsCmdIf _ _ e ct ce)   = sep [hsep [text "if", nest 2 (ppr e), ptext (sLit "then")],          nest 4 (ppr ct),@@ -1496,15 +1514,16 @@   = hang (text "(|" <+> ppr_lexpr op)          4 (sep (map (pprCmdArg.unLoc) args) <+> text "|)") ppr_cmd (XCmd x) = case ghcPass @p of+#if __GLASGOW_HASKELL__ < 811   GhcPs -> ppr x   GhcRn -> ppr x+#endif   GhcTc -> case x of     HsWrap w cmd -> pprHsWrapper w (\_ -> parens (ppr_cmd cmd))  pprCmdArg :: (OutputableBndrId p) => HsCmdTop (GhcPass p) -> SDoc pprCmdArg (HsCmdTop _ cmd)   = ppr_lcmd cmd-pprCmdArg (XCmdTop x) = ppr x  instance (OutputableBndrId p) => Outputable (HsCmdTop (GhcPass p)) where     ppr = pprCmdArg@@ -1549,7 +1568,7 @@      -- The type is the type of the entire group      --      t1 -> ... -> tn -> tr      -- where there are n patterns-  | XMatchGroup (XXMatchGroup p body)+  | XMatchGroup !(XXMatchGroup p body)  data MatchGroupTc   = MatchGroupTc@@ -1568,7 +1587,7 @@ -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' when in a --   list --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data Match p body   = Match {         m_ext :: XCMatch p body,@@ -1577,7 +1596,7 @@         m_pats :: [LPat p], -- The patterns         m_grhss :: (GRHSs p body)   }-  | XMatch (XXMatch p body)+  | XMatch !(XXMatch p body)  type instance XCMatch (GhcPass _) b = NoExtField type instance XXMatch (GhcPass _) b = NoExtCon@@ -1647,11 +1666,9 @@ matchGroupArity (MG { mg_alts = alts })   | L _ (alt1:_) <- alts = length (hsLMatchPats alt1)   | otherwise        = panic "matchGroupArity"-matchGroupArity (XMatchGroup nec) = noExtCon nec  hsLMatchPats :: LMatch (GhcPass id) body -> [LPat (GhcPass id)] hsLMatchPats (L _ (Match { m_pats = pats })) = pats-hsLMatchPats (L _ (XMatch nec)) = noExtCon nec  -- | Guarded Right-Hand Sides --@@ -1662,14 +1679,14 @@ --        'ApiAnnotation.AnnOpen','ApiAnnotation.AnnClose' --        'ApiAnnotation.AnnRarrow','ApiAnnotation.AnnSemi' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data GRHSs p body   = GRHSs {       grhssExt :: XCGRHSs p body,       grhssGRHSs :: [LGRHS p body],      -- ^ Guarded RHSs       grhssLocalBinds :: LHsLocalBinds p -- ^ The where clause     }-  | XGRHSs (XXGRHSs p body)+  | XGRHSs !(XXGRHSs p body)  type instance XCGRHSs (GhcPass _) b = NoExtField type instance XXGRHSs (GhcPass _) b = NoExtCon@@ -1681,7 +1698,7 @@ data GRHS p body = GRHS (XCGRHS p body)                         [GuardLStmt p] -- Guards                         body           -- Right hand side-                  | XGRHS (XXGRHS p body)+                  | XGRHS !(XXGRHS p body)  type instance XCGRHS (GhcPass _) b = NoExtField type instance XXGRHS (GhcPass _) b = NoExtCon@@ -1693,7 +1710,6 @@ pprMatches MG { mg_alts = matches }     = vcat (map pprMatch (map unLoc (unLoc matches)))       -- Don't print the type; it's only a place-holder before typechecking-pprMatches (XMatchGroup x) = ppr x  -- Exported to GHC.Hs.Binds, which can't see the defn of HsMatchContext pprFunBind :: (OutputableBndrId idR, Outputable body)@@ -1743,7 +1759,6 @@                    []    -> (empty, [])                    [pat] -> (ppr pat, [])  -- No parens around the single pat in a case                    _     -> pprPanic "pprMatch" (ppr ctxt $$ ppr pats)-pprMatch (XMatch nec) = noExtCon nec  pprGRHSs :: (OutputableBndrId idR, Outputable body)          => HsMatchContext passL -> GRHSs (GhcPass idR) body -> SDoc@@ -1753,7 +1768,6 @@   -- EmptyLocalBinds means no "where" keyword  $$ ppUnless (eqEmptyLocalBinds binds)       (text "where" $$ nest 4 (pprBinds binds))-pprGRHSs _ (XGRHSs x) = ppr x  pprGRHS :: (OutputableBndrId idR, Outputable body)         => HsMatchContext passL -> GRHS (GhcPass idR) body -> SDoc@@ -1763,8 +1777,6 @@ pprGRHS ctxt (GRHS _ guards body)  = sep [vbar <+> interpp'SP guards, pp_rhs ctxt body] -pprGRHS _ (XGRHS x) = ppr x- pp_rhs :: Outputable body => HsMatchContext passL -> body -> SDoc pp_rhs ctxt rhs = matchSeparator ctxt <+> pprDeeper (ppr rhs) @@ -1817,7 +1829,7 @@ --         'ApiAnnotation.AnnBy','ApiAnnotation.AnnBy', --         'ApiAnnotation.AnnGroup','ApiAnnotation.AnnUsing' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data StmtLR idL idR body -- body should always be (LHs**** idR)   = LastStmt  -- Always the last Stmt in ListComp, MonadComp,               -- and (after the renamer, see GHC.Rename.Expr.checkLastStmt) DoExpr, MDoExpr@@ -1835,17 +1847,15 @@             -- See Note [Monad Comprehensions]             -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLarrow' -  -- For details on above see note [Api annotations] in ApiAnnotation-  | BindStmt (XBindStmt idL idR body) -- Post typechecking,-                                -- result type of the function passed to bind;-                                -- that is, S in (>>=) :: Q -> (R -> S) -> T+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | BindStmt (XBindStmt idL idR body)+             -- ^ Post renaming has optional fail and bind / (>>=) operator.+             -- Post typechecking, also has result type of the+             -- function passed to bind; that is, S in (>>=)+             -- :: Q -> (R -> S) -> T+             -- See Note [The type of bind in Stmts]              (LPat idL)              body-             (SyntaxExpr idR) -- The (>>=) operator; see Note [The type of bind in Stmts]-             (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@@ -1871,7 +1881,7 @@   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnLet'   --          'ApiAnnotation.AnnOpen' @'{'@,'ApiAnnotation.AnnClose' @'}'@, -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | LetStmt  (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)    -- ParStmts only occur in a list/monad comprehension@@ -1909,7 +1919,7 @@   -- Recursive statement (see Note [How RecStmt works] below)   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRec' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | RecStmt      { recS_ext :: XRecStmt idL idR body      , recS_stmts :: [LStmtLR idL idR body]@@ -1932,7 +1942,7 @@      , recS_ret_fn  :: SyntaxExpr idR -- The return function      , recS_mfix_fn :: SyntaxExpr idR -- The mfix function       }-  | XStmtLR (XXStmtLR idL idR body)+  | XStmtLR !(XXStmtLR idL idR body)  -- Extra fields available post typechecking for RecStmt. data RecStmtTc =@@ -1958,9 +1968,20 @@ type instance XLastStmt        (GhcPass _) (GhcPass _) b = NoExtField  type instance XBindStmt        (GhcPass _) GhcPs b = NoExtField-type instance XBindStmt        (GhcPass _) GhcRn b = NoExtField-type instance XBindStmt        (GhcPass _) GhcTc b = Type+type instance XBindStmt        (GhcPass _) GhcRn b = XBindStmtRn+type instance XBindStmt        (GhcPass _) GhcTc b = XBindStmtTc +data XBindStmtRn = XBindStmtRn+  { xbsrn_bindOp :: SyntaxExpr GhcRn+  , xbsrn_failOp :: FailOperator GhcRn+  }++data XBindStmtTc = XBindStmtTc+  { xbstc_bindOp :: SyntaxExpr GhcTc+  , xbstc_boundResultType :: Type -- If (>>=) :: Q -> (R -> S) -> T, this is S+  , xbstc_failOp :: FailOperator GhcTc+  }+ type instance XApplicativeStmt (GhcPass _) GhcPs b = NoExtField type instance XApplicativeStmt (GhcPass _) GhcRn b = NoExtField type instance XApplicativeStmt (GhcPass _) GhcTc b = Type@@ -1997,39 +2018,60 @@         [ExprLStmt idL]         [IdP idR]          -- The variables to be returned         (SyntaxExpr idR)   -- The return operator-  | XParStmtBlock (XXParStmtBlock idL idR)+  | XParStmtBlock !(XXParStmtBlock idL idR)  type instance XParStmtBlock  (GhcPass pL) (GhcPass pR) = NoExtField type instance XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon +-- | The fail operator+--+-- This is used for `.. <-` "bind statments" in do notation, including+-- non-monadic "binds" in applicative.+--+-- The fail operator is 'Just expr' if it potentially fail monadically. if the+-- pattern match cannot fail, or shouldn't fail monadically (regular incomplete+-- pattern exception), it is 'Nothing'.+--+-- See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of+-- expression in the 'Just' case, and why it is so.+--+-- See Note [Failing pattern matches in Stmts] for which contexts for+-- '@BindStmt@'s should use the monadic fail and which shouldn't.+type FailOperator id = Maybe (SyntaxExpr id)+ -- | Applicative Argument data ApplicativeArg idL   = ApplicativeArgOne      -- A single statement (BindStmt or BodyStmt)-    { xarg_app_arg_one  :: (XApplicativeArgOne idL)-    , app_arg_pattern   :: (LPat idL) -- WildPat if it was a BodyStmt (see below)-    , arg_expr          :: (LHsExpr idL)-    , is_body_stmt      :: Bool -- True <=> was a BodyStmt-                              -- False <=> was a BindStmt-                              -- See Note [Applicative BodyStmt]-    , fail_operator     :: (SyntaxExpr idL) -- The fail operator-                         -- The fail operator is needed if this is a BindStmt-                         -- where the pattern can fail. E.g.:-                         -- (Just a) <- stmt-                         -- The fail operator will be invoked if the pattern-                         -- match fails.-                         -- The fail operator is noSyntaxExpr-                         -- if the pattern match can't fail-                         -- See Note [NoSyntaxExpr] (2)+    { xarg_app_arg_one  :: XApplicativeArgOne idL+      -- ^ The fail operator, after renaming+      --+      -- The fail operator is needed if this is a BindStmt+      -- where the pattern can fail. E.g.:+      -- (Just a) <- stmt+      -- The fail operator will be invoked if the pattern+      -- match fails.+      -- It is also used for guards in MonadComprehensions.+      -- The fail operator is Nothing+      -- if the pattern match can't fail+    , app_arg_pattern   :: LPat idL -- WildPat if it was a BodyStmt (see below)+    , arg_expr          :: LHsExpr idL+    , is_body_stmt      :: Bool+      -- ^ True <=> was a BodyStmt,+      -- False <=> was a BindStmt.+      -- See Note [Applicative BodyStmt]     }   | ApplicativeArgMany     -- do { stmts; return vars }-    { xarg_app_arg_many :: (XApplicativeArgMany idL)+    { xarg_app_arg_many :: XApplicativeArgMany idL     , app_stmts         :: [ExprLStmt idL] -- stmts-    , final_expr        :: (HsExpr idL)    -- return (v1,..,vn), or just (v1,..,vn)-    , bv_pattern        :: (LPat idL)      -- (v1,...,vn)+    , final_expr        :: HsExpr idL    -- return (v1,..,vn), or just (v1,..,vn)+    , bv_pattern        :: LPat idL      -- (v1,...,vn)     }-  | XApplicativeArg (XXApplicativeArg idL)+  | XApplicativeArg !(XXApplicativeArg idL) -type instance XApplicativeArgOne  (GhcPass _) = NoExtField+type instance XApplicativeArgOne GhcPs = NoExtField+type instance XApplicativeArgOne GhcRn = FailOperator GhcRn+type instance XApplicativeArgOne GhcTc = FailOperator GhcTc+ type instance XApplicativeArgMany (GhcPass _) = NoExtField type instance XXApplicativeArg    (GhcPass _) = NoExtCon @@ -2220,7 +2262,7 @@         Just False -> text "return"         Nothing -> empty) <+>       ppr expr-pprStmt (BindStmt _ pat expr _ _) = hsep [ppr pat, larrow, ppr expr]+pprStmt (BindStmt _ pat expr) = hsep [ppr pat, larrow, ppr expr] pprStmt (LetStmt _ (L _ binds))   = hsep [text "let", pprBinds binds] pprStmt (BodyStmt _ expr _ _)     = ppr expr pprStmt (ParStmt _ stmtss _ _)   = sep (punctuate (text " | ") (map ppr stmtss))@@ -2255,16 +2297,14 @@    flattenStmt stmt = [ppr stmt]     flattenArg :: forall a . (a, ApplicativeArg (GhcPass idL)) -> [SDoc]-   flattenArg (_, ApplicativeArgOne _ pat expr isBody _)+   flattenArg (_, ApplicativeArgOne _ pat expr isBody)      | isBody =  -- See Note [Applicative BodyStmt]      [ppr (BodyStmt (panic "pprStmt") expr noSyntaxExpr noSyntaxExpr              :: ExprStmt (GhcPass idL))]      | otherwise =-     [ppr (BindStmt (panic "pprStmt") pat expr noSyntaxExpr noSyntaxExpr-             :: ExprStmt (GhcPass idL))]+     [ppr (BindStmt (panic "pprStmt") pat expr :: ExprStmt (GhcPass idL))]    flattenArg (_, ApplicativeArgMany _ stmts _ _) =      concatMap flattenStmt stmts-   flattenArg (_, XApplicativeArg nec) = noExtCon nec     pp_debug =      let@@ -2276,21 +2316,18 @@    pp_arg :: (a, ApplicativeArg (GhcPass idL)) -> SDoc    pp_arg (_, applicativeArg) = ppr applicativeArg -pprStmt (XStmtLR x) = ppr x - instance (OutputableBndrId idL)       => Outputable (ApplicativeArg (GhcPass idL)) where   ppr = pprArg  pprArg :: forall idL . (OutputableBndrId idL) => ApplicativeArg (GhcPass idL) -> SDoc-pprArg (ApplicativeArgOne _ pat expr isBody _)+pprArg (ApplicativeArgOne _ pat expr isBody)   | isBody =  -- See Note [Applicative BodyStmt]     ppr (BodyStmt (panic "pprStmt") expr noSyntaxExpr noSyntaxExpr             :: ExprStmt (GhcPass idL))   | otherwise =-    ppr (BindStmt (panic "pprStmt") pat expr noSyntaxExpr noSyntaxExpr-            :: ExprStmt (GhcPass idL))+    ppr (BindStmt (panic "pprStmt") pat expr :: ExprStmt (GhcPass idL)) pprArg (ApplicativeArgMany _ stmts return pat) =      ppr pat <+>      text "<-" <+>@@ -2298,8 +2335,6 @@                (stmts ++                    [noLoc (LastStmt noExtField (noLoc return) Nothing noSyntaxExpr)]))) -pprArg (XApplicativeArg x) = ppr x- pprTransformStmt :: (OutputableBndrId p)                  => [IdP (GhcPass p)] -> LHsExpr (GhcPass p)                  -> Maybe (LHsExpr (GhcPass p)) -> SDoc@@ -2376,7 +2411,7 @@         (IdP id)         -- A unique name to identify this splice point         (LHsExpr id)     -- See Note [Pending Splices] -   | HsQuasiQuote        -- See Note [Quasi-quote overview] in TcSplice+   | HsQuasiQuote        -- See Note [Quasi-quote overview] in GHC.Tc.Gen.Splice         (XQuasiQuote id)         (IdP id)         -- Splice point         (IdP id)         -- Quoter@@ -2392,7 +2427,7 @@         (XSpliced id)         ThModFinalizers     -- TH finalizers produced by the splice.         (HsSplicedThing id) -- The result of splicing-   | XSplice (XXSplice id)  -- Note [Trees that Grow] extension point+   | XSplice !(XXSplice id) -- Note [Trees that Grow] extension point  newtype HsSplicedT = HsSplicedT DelayedSplice deriving (Data) @@ -2435,7 +2470,7 @@   dataTypeOf a  = mkDataType "HsExpr.ThModFinalizers" [toConstr a]  -- See Note [Running typed splices in the zonker]--- These are the arguments that are passed to `TcSplice.runTopSplice`+-- These are the arguments that are passed to `GHC.Tc.Gen.Splice.runTopSplice` data DelayedSplice =   DelayedSplice     TcLclEnv          -- The local environment to run the splice in@@ -2551,7 +2586,7 @@  pprPendingSplice :: (OutputableBndrId p)                  => SplicePointName -> LHsExpr (GhcPass p) -> SDoc-pprPendingSplice n e = angleBrackets (ppr n <> comma <+> ppr (stripParensHsExpr e))+pprPendingSplice n e = angleBrackets (ppr n <> comma <+> ppr (stripParensLHsExpr e))  pprSpliceDecl ::  (OutputableBndrId p)           => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc@@ -2576,8 +2611,10 @@ pprSplice (HsQuasiQuote _ n q _ s)      = ppr_quasi n q s pprSplice (HsSpliced _ _ thing)         = ppr thing pprSplice (XSplice x)                   = case ghcPass @p of+#if __GLASGOW_HASKELL__ < 811                                             GhcPs -> noExtCon x                                             GhcRn -> noExtCon x+#endif                                             GhcTc -> case x of                                                        HsSplicedT _ -> text "Unevaluated typed splice" @@ -2601,7 +2638,7 @@   | VarBr  (XVarBr p)   Bool (IdP p)  -- True: 'x, False: ''T                                 -- (The Bool flag is used only in pprHsBracket)   | TExpBr (XTExpBr p) (LHsExpr p)    -- [||  expr  ||]-  | XBracket (XXBracket p)            -- Note [Trees that Grow] extension point+  | XBracket !(XXBracket p)           -- Note [Trees that Grow] extension point  type instance XExpBr      (GhcPass _) = NoExtField type instance XPatBr      (GhcPass _) = NoExtField@@ -2632,7 +2669,6 @@ pprHsBracket (VarBr _ False n)   = text "''" <> pprPrefixOcc n pprHsBracket (TExpBr _ e)  = thTyBrackets (ppr e)-pprHsBracket (XBracket e)  = ppr e  thBrackets :: SDoc -> SDoc -> SDoc thBrackets pp_kind pp_body = char '[' <> pp_kind <> vbar <+>
compiler/GHC/Hs/Expr.hs-boot view
@@ -11,7 +11,7 @@ module GHC.Hs.Expr where  import GHC.Types.SrcLoc     ( Located )-import Outputable ( SDoc, Outputable )+import GHC.Utils.Outputable ( SDoc, Outputable ) import {-# SOURCE #-} GHC.Hs.Pat  ( LPat ) import GHC.Types.Basic  ( SpliceExplicitFlag(..)) import GHC.Hs.Extension ( OutputableBndrId, GhcPass )
compiler/GHC/Hs/Extension.hs view
@@ -25,13 +25,13 @@ -- This module captures the type families to precisely identify the extension -- points for GHC.Hs syntax -import GhcPrelude+import GHC.Prelude  import Data.Data hiding ( Fixity ) import GHC.Types.Name import GHC.Types.Name.Reader import GHC.Types.Var-import Outputable+import GHC.Utils.Outputable import GHC.Types.SrcLoc (Located)  import Data.Kind@@ -181,32 +181,27 @@   type instance XXHsDecl (GhcPass _) = NoExtCon   data HsDecl p     = ...-    | XHsDecl (XXHsDecl p)+    | XHsDecl !(XXHsDecl p) -This means that any function that wishes to consume an HsDecl will need to-have a case for XHsDecl. This might look like this:+The field of type `XXHsDecl p` is strict for a good reason: it allows the+pattern-match coverage checker to conclude that any matches against XHsDecl+are unreachable whenever `p ~ GhcPass _`. To see why this is the case, consider+the following function which consumes an HsDecl:    ex :: HsDecl GhcPs -> HsDecl GhcRn   ...   ex (XHsDecl nec) = noExtCon nec -Ideally, we wouldn't need a case for XHsDecl at all (it /is/ supposed to be-an unused extension constructor, after all). There is a way to achieve this-on GHC 8.8 or later: make the field of XHsDecl strict:--  data HsDecl p-    = ...-    | XHsDecl !(XXHsDecl p)--If this is done, GHC's pattern-match coverage checker is clever enough to-figure out that the XHsDecl case of `ex` is unreachable, so it can simply be-omitted. (See Note [Extensions to GADTs Meet Their Match] in Check for more on-how this works.)+Because `p` equals GhcPs (i.e., GhcPass 'Parsed), XHsDecl's field has the type+NoExtCon. But since (1) the field is strict and (2) NoExtCon is an empty data+type, there is no possible way to reach the right-hand side of the XHsDecl+case. As a result, the coverage checker concludes that the XHsDecl case is+inaccessible, so it can be removed.+(See Note [Strict argument type constraints] in GHC.HsToCore.PmCheck.Oracle for+more on how this works.) -When GHC drops support for bootstrapping with GHC 8.6 and earlier, we can make-the strict field changes described above and delete gobs of code involving-`noExtCon`. Until then, it is necessary to use, so be aware of it when writing-code that consumes unused extension constructors.+Bottom line: if you add a TTG extension constructor that uses NoExtCon, make+sure that any uses of it as a field are strict. -}  -- | Used as a data type index for the hsSyn AST; also serves@@ -604,6 +599,7 @@ type family XCmdLam     x type family XCmdPar     x type family XCmdCase    x+type family XCmdLamCase x type family XCmdIf      x type family XCmdLet     x type family XCmdDo      x
compiler/GHC/Hs/ImpExp.hs view
@@ -16,16 +16,16 @@  module GHC.Hs.ImpExp where -import GhcPrelude+import GHC.Prelude -import GHC.Types.Module       ( ModuleName )+import GHC.Unit.Module       ( ModuleName ) import GHC.Hs.Doc             ( HsDocString ) import GHC.Types.Name.Occurrence ( HasOccName(..), isTcOcc, isSymOcc ) import GHC.Types.Basic        ( SourceText(..), StringLiteral(..), pprWithSourceText ) import GHC.Types.FieldLabel   ( FieldLbl(..) ) -import Outputable-import FastString+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Types.SrcLoc import GHC.Hs.Extension @@ -48,7 +48,7 @@         --         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | If/how an import is 'qualified'. data ImportDeclQualifiedStyle@@ -59,7 +59,7 @@  -- | Given two possible located 'qualified' tokens, compute a style -- (in a conforming Haskell program only one of the two can be not--- 'Nothing'). This is called from 'Parser.y'.+-- 'Nothing'). This is called from 'GHC.Parser'. importDeclQualifiedStyle :: Maybe (Located a)                          -> Maybe (Located a)                          -> ImportDeclQualifiedStyle@@ -91,7 +91,7 @@       ideclHiding    :: Maybe (Bool, Located [LIE pass])                                        -- ^ (True => hiding, names)     }-  | XImportDecl (XXImportDecl pass)+  | XImportDecl !(XXImportDecl pass)      -- ^      --  'ApiAnnotation.AnnKeywordId's      --@@ -107,7 +107,7 @@      --    'ApiAnnotation.AnnClose' attached      --     to location in ideclHiding -     -- For details on above see note [Api annotations] in ApiAnnotation+     -- For details on above see note [Api annotations] in GHC.Parser.Annotation  type instance XCImportDecl  (GhcPass _) = NoExtField type instance XXImportDecl  (GhcPass _) = NoExtCon@@ -167,7 +167,6 @@          ppr_ies []  = text "()"         ppr_ies ies = char '(' <+> interpp'SP ies <+> char ')'-    ppr (XImportDecl x) = ppr x  {- ************************************************************************@@ -190,7 +189,7 @@ -- - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnType', --         'ApiAnnotation.AnnPattern' type LIEWrappedName name = Located (IEWrappedName name)--- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation   -- | Located Import or Export@@ -199,7 +198,7 @@         --         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Imported or exported entity. data IE pass@@ -213,7 +212,7 @@         --  - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnPattern',         --             'ApiAnnotation.AnnType','ApiAnnotation.AnnVal' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation         -- See Note [Located RdrNames] in GHC.Hs.Expr   | IEThingAll  (XIEThingAll pass) (LIEWrappedName (IdP pass))         -- ^ Imported or exported Thing with All imported or exported@@ -224,7 +223,7 @@         --       'ApiAnnotation.AnnDotdot','ApiAnnotation.AnnClose',         --                                 'ApiAnnotation.AnnType' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation         -- See Note [Located RdrNames] in GHC.Hs.Expr    | IEThingWith (XIEThingWith pass)@@ -241,7 +240,7 @@         --                                   'ApiAnnotation.AnnComma',         --                                   'ApiAnnotation.AnnType' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | IEModuleContents  (XIEModuleContents pass) (Located ModuleName)         -- ^ Imported or exported module contents         --@@ -249,11 +248,11 @@         --         -- - 'ApiAnnotation.AnnKeywordId's : 'ApiAnnotation.AnnModule' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | IEGroup             (XIEGroup pass) Int HsDocString -- ^ Doc section heading   | IEDoc               (XIEDoc pass) HsDocString       -- ^ Some documentation   | IEDocNamed          (XIEDocNamed pass) String    -- ^ Reference to named doc-  | XIE (XXIE pass)+  | XIE !(XXIE pass)  type instance XIEVar             (GhcPass _) = NoExtField type instance XIEThingAbs        (GhcPass _) = NoExtField@@ -302,7 +301,6 @@ ieNames (IEGroup          {})     = [] ieNames (IEDoc            {})     = [] ieNames (IEDocNamed       {})     = []-ieNames (XIE nec) = noExtCon nec  ieWrappedName :: IEWrappedName name -> name ieWrappedName (IEName    (L _ n)) = n@@ -344,7 +342,6 @@     ppr (IEGroup _ n _)           = text ("<IEGroup: " ++ show n ++ ">")     ppr (IEDoc _ doc)             = ppr doc     ppr (IEDocNamed _ string)     = text ("<IEDocNamed: " ++ string ++ ">")-    ppr (XIE x) = ppr x  instance (HasOccName name) => HasOccName (IEWrappedName name) where   occName w = occName (ieWrappedName w)
compiler/GHC/Hs/Instances.hs view
@@ -16,7 +16,7 @@  import Data.Data hiding ( Fixity ) -import GhcPrelude+import GHC.Prelude import GHC.Hs.Extension import GHC.Hs.Binds import GHC.Hs.Decls@@ -334,6 +334,9 @@ deriving instance Data SyntaxExprRn deriving instance Data SyntaxExprTc +deriving instance Data XBindStmtRn+deriving instance Data XBindStmtTc+ -- --------------------------------------------------------------------- -- Data derivations from GHC.Hs.Lit ------------------------------------ @@ -354,6 +357,9 @@ deriving instance Data (Pat GhcPs) deriving instance Data (Pat GhcRn) deriving instance Data (Pat GhcTc)++deriving instance Data CoPat+deriving instance Data ConPatTc  deriving instance Data ListPatTc
compiler/GHC/Hs/Lit.hs view
@@ -19,7 +19,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Hs.Expr( HsExpr, pprExpr ) import GHC.Types.Basic@@ -27,8 +27,8 @@    , negateFractionalLit, SourceText(..), pprWithSourceText    , PprPrec(..), topPrec ) import GHC.Core.Type-import Outputable-import FastString+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Hs.Extension  import Data.ByteString (ByteString)@@ -57,7 +57,7 @@       -- ^ Packed bytes   | HsInt (XHsInt x)  IntegralLit       -- ^ Genuinely an Int; arises from-      -- @TcGenDeriv@, and from TRANSLATION+      -- @GHC.Tc.Deriv.Generate@, and from TRANSLATION   | HsIntPrim (XHsIntPrim x) {- SourceText -} Integer       -- ^ literal @Int#@   | HsWordPrim (XHsWordPrim x) {- SourceText -} Integer@@ -79,7 +79,7 @@   | HsDoublePrim (XHsDoublePrim x) FractionalLit       -- ^ Unboxed Double -  | XLit (XXLit x)+  | XLit !(XXLit x)  type instance XHsChar       (GhcPass _) = SourceText type instance XHsCharPrim   (GhcPass _) = SourceText@@ -120,7 +120,7 @@       ol_witness :: HsExpr p}         -- Note [Overloaded literal witnesses]    | XOverLit-      (XXOverLit p)+      !(XXOverLit p)  data OverLitTc   = OverLitTc {@@ -150,7 +150,6 @@  overLitType :: HsOverLit GhcTc -> Type overLitType (OverLit (OverLitTc _ ty) _ _) = ty-overLitType (XOverLit nec) = noExtCon nec  -- | Convert a literal from one index type to another convertLit :: HsLit (GhcPass p1) -> HsLit (GhcPass p2)@@ -167,7 +166,6 @@ 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]@@ -244,7 +242,6 @@     ppr (HsWordPrim st w)   = pprWithSourceText st (pprPrimWord w)     ppr (HsInt64Prim st i)  = pp_st_suffix st primInt64Suffix  (pprPrimInt64 i)     ppr (HsWord64Prim st w) = pp_st_suffix st primWord64Suffix (pprPrimWord64 w)-    ppr (XLit x) = ppr x  pp_st_suffix :: SourceText -> SDoc -> SDoc -> SDoc pp_st_suffix NoSourceText         _ doc = doc@@ -255,7 +252,6 @@        => Outputable (HsOverLit (GhcPass p)) where   ppr (OverLit {ol_val=val, ol_witness=witness})         = ppr val <+> (whenPprDebug (parens (pprExpr witness)))-  ppr (XOverLit x) = ppr x  instance Outputable OverLitVal where   ppr (HsIntegral i)     = pprWithSourceText (il_text i) (integer (il_value i))@@ -282,7 +278,6 @@ pmPprHsLit (HsRat _ f _)      = ppr f pmPprHsLit (HsFloatPrim _ f)  = ppr f pmPprHsLit (HsDoublePrim _ d) = ppr d-pmPprHsLit (XLit x)           = ppr x  -- | @'hsLitNeedsParens' p l@ returns 'True' if a literal @l@ needs -- to be parenthesized under precedence @p@.
compiler/GHC/Hs/Pat.hs view
@@ -10,6 +10,7 @@ {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE CPP #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]@@ -23,8 +24,11 @@ {-# LANGUAGE LambdaCase #-}  module GHC.Hs.Pat (-        Pat(..), InPat, OutPat, LPat,+        Pat(..), LPat,+        ConPatTc (..),+        CoPat (..),         ListPatTc(..),+        ConLikeP,          HsConPatDetails, hsConPatArgs,         HsRecFields(..), HsRecField'(..), LHsRecField',@@ -46,7 +50,7 @@         pprParendLPat, pprConArgs     ) where -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Hs.Expr (SyntaxExpr, LHsExpr, HsSplice, pprLExpr, pprSplice) @@ -55,35 +59,32 @@ import GHC.Hs.Lit import GHC.Hs.Extension import GHC.Hs.Types-import TcEvidence+import GHC.Tc.Types.Evidence import GHC.Types.Basic -- others: import GHC.Core.Ppr ( {- instance OutputableBndr TyVar -} )-import GHC.Driver.Session ( gopt, GeneralFlag(Opt_PrintTypecheckerElaboration) )-import TysWiredIn+import GHC.Builtin.Types import GHC.Types.Var import GHC.Types.Name.Reader ( RdrName ) import GHC.Core.ConLike import GHC.Core.DataCon import GHC.Core.TyCon-import Outputable+import GHC.Utils.Outputable import GHC.Core.Type import GHC.Types.SrcLoc-import Bag -- collect ev vars from pats-import Maybes+import GHC.Data.Bag -- collect ev vars from pats+import GHC.Data.Maybe+import GHC.Types.Name (Name) -- libraries: import Data.Data hiding (TyCon,Fixity) -type InPat p  = LPat p        -- No 'Out' constructors-type OutPat p = LPat p        -- No 'In' constructors- type LPat p = XRec p Pat  -- | Pattern -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnBang' --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data Pat p   =     ------------ Simple patterns ---------------     WildPat     (XWildPat p)        -- ^ Wildcard Pattern@@ -99,13 +100,13 @@                 (LPat p)                -- ^ Lazy Pattern     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnTilde' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | AsPat       (XAsPat p)                 (Located (IdP p)) (LPat p)    -- ^ As pattern     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnAt' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | ParPat      (XParPat p)                 (LPat p)                -- ^ Parenthesised pattern@@ -113,12 +114,12 @@     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,     --                                    'ApiAnnotation.AnnClose' @')'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | BangPat     (XBangPat p)                 (LPat p)                -- ^ Bang pattern     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnBang' -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation          ------------ Lists, tuples, arrays ---------------   | ListPat     (XListPat p)@@ -132,7 +133,7 @@     -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@,     --                                    'ApiAnnotation.AnnClose' @']'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | TuplePat    (XTuplePat p)                   -- after typechecking, holds the types of the tuple components@@ -170,38 +171,20 @@     --            'ApiAnnotation.AnnOpen' @'(#'@,     --            'ApiAnnotation.AnnClose' @'#)'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation          ------------ Constructor patterns ----------------  | ConPatIn    (Located (IdP p))-                (HsConPatDetails p)-    -- ^ Constructor Pattern In--  | ConPatOut {-        pat_con     :: Located ConLike,-        pat_arg_tys :: [Type],          -- The universal arg types, 1-1 with the universal-                                        -- tyvars of the constructor/pattern synonym-                                        --   Use (conLikeResTy pat_con pat_arg_tys) to get-                                        --   the type of the pattern--        pat_tvs   :: [TyVar],           -- Existentially bound type variables-                                        -- in correctly-scoped order e.g. [k:*, x:k]-        pat_dicts :: [EvVar],           -- Ditto *coercion variables* and *dictionaries*-                                        -- One reason for putting coercion variable here, I think,-                                        --      is to ensure their kinds are zonked--        pat_binds :: TcEvBinds,         -- Bindings involving those dictionaries-        pat_args  :: HsConPatDetails p,-        pat_wrap  :: HsWrapper          -- Extra wrapper to pass to the matcher-                                        -- Only relevant for pattern-synonyms;-                                        --   ignored for data cons+  | ConPat {+        pat_con_ext :: XConPat p,+        pat_con     :: Located (ConLikeP p),+        pat_args    :: HsConPatDetails p     }-    -- ^ Constructor Pattern Out+    -- ^ Constructor Pattern          ------------ View patterns ---------------   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | ViewPat       (XViewPat p)     -- The overall type of the pattern                                    -- (= the argument type of the view function)                                    -- for hsPatType.@@ -213,7 +196,7 @@   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'$('@   --        'ApiAnnotation.AnnClose' @')'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | SplicePat       (XSplicePat p)                     (HsSplice p)    -- ^ Splice Pattern (Includes quasi-quotes) @@ -239,11 +222,11 @@   --   -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnVal' @'+'@ -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | NPlusKPat       (XNPlusKPat p)           -- Type of overall pattern                     (Located (IdP p))        -- n+k pattern                     (Located (HsOverLit p))  -- It'll always be an HsIntegral-                    (HsOverLit p)       -- See Note [NPlusK patterns] in TcPat+                    (HsOverLit p)            -- See Note [NPlusK patterns] in GHC.Tc.Gen.Pat                      -- NB: This could be (PostTc ...), but that induced a                      -- a new hs-boot file. Not worth it. @@ -254,7 +237,7 @@         ------------ Pattern type signatures ---------------   -- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -  -- For details on above see note [Api annotations] in ApiAnnotation+  -- For details on above see note [Api annotations] in GHC.Parser.Annotation   | SigPat          (XSigPat p)             -- After typechecker: Type                     (LPat p)                -- Pattern with a type signature                     (LHsSigWcType (NoGhcTc p)) --  Signature can bind both@@ -262,20 +245,9 @@      -- ^ Pattern with a type signature -        ------------ Pattern coercions (translation only) ----------------  | CoPat       (XCoPat p)-                HsWrapper           -- Coercion Pattern-                                    -- If co :: t1 ~ t2, p :: t2,-                                    -- then (CoPat co p) :: t1-                (Pat p)             -- Why not LPat?  Ans: existing locn will do-                Type                -- Type of whole pattern, t1-        -- During desugaring a (CoPat co pat) turns into a cast with 'co' on-        -- the scrutinee, followed by a match on 'pat'-    -- ^ Coercion Pattern-   -- | Trees that Grow extension point for new constructors   | XPat-      (XXPat p)+      !(XXPat p)   -- ---------------------------------------------------------------------@@ -306,6 +278,10 @@ type instance XTuplePat GhcRn = NoExtField type instance XTuplePat GhcTc = [Type] +type instance XConPat GhcPs = NoExtField+type instance XConPat GhcRn = NoExtField+type instance XConPat GhcTc = ConPatTc+ type instance XSumPat GhcPs = NoExtField type instance XSumPat GhcRn = NoExtField type instance XSumPat GhcTc = [Type]@@ -329,10 +305,17 @@ type instance XSigPat GhcRn = NoExtField type instance XSigPat GhcTc = Type -type instance XCoPat  (GhcPass _) = NoExtField+type instance XXPat GhcPs = NoExtCon+type instance XXPat GhcRn = NoExtCon+type instance XXPat GhcTc = CoPat+  -- After typechecking, we add one extra constructor: CoPat -type instance XXPat   (GhcPass _) = NoExtCon+type family ConLikeP x +type instance ConLikeP GhcPs = RdrName -- IdP GhcPs+type instance ConLikeP GhcRn = Name -- IdP GhcRn+type instance ConLikeP GhcTc = ConLike+ -- ---------------------------------------------------------------------  @@ -344,6 +327,52 @@ hsConPatArgs (RecCon fs)      = map (hsRecFieldArg . unLoc) (rec_flds fs) hsConPatArgs (InfixCon p1 p2) = [p1,p2] +-- | This is the extension field for ConPat, added after typechecking+-- It adds quite a few extra fields, to support elaboration of pattern matching.+data ConPatTc+  = ConPatTc+    { -- | The universal arg types  1-1 with the universal+      -- tyvars of the constructor/pattern synonym+      -- Use (conLikeResTy pat_con cpt_arg_tys) to get+      -- the type of the pattern+      cpt_arg_tys :: [Type]++    , -- | Existentially bound type variables+      -- in correctly-scoped order e.g. [k:*  x:k]+      cpt_tvs   :: [TyVar]++    , -- | Ditto *coercion variables* and *dictionaries*+      -- One reason for putting coercion variable here  I think+      --      is to ensure their kinds are zonked+      cpt_dicts :: [EvVar]++    , -- | Bindings involving those dictionaries+      cpt_binds :: TcEvBinds++    , -- ^ Extra wrapper to pass to the matcher+      -- Only relevant for pattern-synonyms;+      --   ignored for data cons+      cpt_wrap  :: HsWrapper+    }++-- | Coercion Pattern (translation only)+--+-- During desugaring a (CoPat co pat) turns into a cast with 'co' on the+-- scrutinee, followed by a match on 'pat'.+data CoPat+  = CoPat+    { -- | Coercion Pattern+      -- If co :: t1 ~ t2, p :: t2,+      -- then (CoPat co p) :: t1+      co_cpt_wrap :: HsWrapper++    , -- | Why not LPat?  Ans: existing locn will do+      co_pat_inner :: Pat GhcTc++    , -- | Type of whole pattern, t1+      co_pat_ty :: Type+    }+ -- | Haskell Record Fields -- -- HsRecFields is used only for patterns and expressions (not data type@@ -389,7 +418,7 @@ -- -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnEqual', ----- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data HsRecField' id arg = HsRecField {         hsRecFieldLbl :: Located id,         hsRecFieldArg :: arg,           -- ^ Filled in by renamer when punning@@ -449,7 +478,7 @@ -- --     hsRecFieldLbl = Unambiguous "x" $sel:x:MkS  :: AmbiguousFieldOcc Id ----- See also Note [Disambiguating record fields] in TcExpr.+-- See also Note [Disambiguating record fields] in GHC.Tc.Gen.Expr.  hsRecFields :: HsRecFields p arg -> [XCFieldOcc p] hsRecFields rbinds = map (unLoc . hsRecFieldSel . unLoc) (rec_flds rbinds)@@ -498,16 +527,23 @@               => PprPrec -> LPat (GhcPass p) -> SDoc pprParendLPat p = pprParendPat p . unLoc -pprParendPat :: (OutputableBndrId p)-             => PprPrec -> Pat (GhcPass p) -> SDoc-pprParendPat p pat = sdocOption sdocPrintTypecheckerElaboration $ \print_tc_elab ->-                     if need_parens print_tc_elab pat-                     then parens (pprPat pat)-                     else  pprPat pat+pprParendPat :: forall p. OutputableBndrId p+             => PprPrec+             -> Pat (GhcPass p)+             -> SDoc+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 print_tc_elab pat-      | CoPat {} <- pat = print_tc_elab-      | otherwise       = patNeedsParens p pat+      | GhcTc <- ghcPass @p+      , XPat ext <- pat+      , CoPat {} <- ext+      = 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@@ -527,12 +563,6 @@ 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 _)       = pprIfTc @p $-                                  sdocWithDynFlags $ \ dflags ->-                                  if gopt Opt_PrintTypecheckerElaboration dflags-                                  then hang (text "CoPat" <+> parens (ppr co))-                                          2 (pprParendPat appPrec pat)-                                  else pprPat pat pprPat (SigPat _ pat ty)        = ppr pat <+> dcolon <+> ppr_ty   where ppr_ty = case ghcPass @p of                    GhcPs -> ppr ty@@ -548,23 +578,37 @@   | otherwise   = tupleParens (boxityTupleSort bx) (pprWithCommas ppr pats) pprPat (SumPat _ pat alt arity) = sumParens (pprAlternative ppr pat alt arity)-pprPat (ConPatIn con details)   = pprUserCon (unLoc con) details-pprPat (ConPatOut { pat_con = con-                  , pat_tvs = tvs-                  , pat_dicts = dicts-                  , pat_binds = binds-                  , pat_args = 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-+pprPat (ConPat { pat_con = con+               , pat_args = details+               , pat_con_ext = ext+               }+       )+  = case ghcPass @p of+      GhcPs -> pprUserCon (unLoc con) details+      GhcRn -> pprUserCon (unLoc con) details+      GhcTc -> 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))+                           , ppr binds ])+            <+> pprConArgs details+        where ConPatTc { cpt_tvs = tvs+                       , cpt_dicts = dicts+                       , cpt_binds = binds+                       } = ext+pprPat (XPat ext) = case ghcPass @p of+#if __GLASGOW_HASKELL__ < 811+  GhcPs -> noExtCon ext+  GhcRn -> noExtCon ext+#endif+  GhcTc -> pprHsWrapper co $ \parens ->+      if parens+      then pprParendPat appPrec pat+      else pprPat pat+    where CoPat co pat _ = ext  pprUserCon :: (OutputableBndr con, OutputableBndrId p)            => con -> HsConPatDetails (GhcPass p) -> SDoc@@ -603,21 +647,24 @@ -}  mkPrefixConPat :: DataCon ->-                  [OutPat (GhcPass p)] -> [Type] -> OutPat (GhcPass p)+                  [LPat GhcTc] -> [Type] -> LPat GhcTc -- Make a vanilla Prefix constructor pattern mkPrefixConPat dc pats tys-  = noLoc $ ConPatOut { pat_con = noLoc (RealDataCon dc)-                      , pat_tvs = []-                      , pat_dicts = []-                      , pat_binds = emptyTcEvBinds-                      , pat_args = PrefixCon pats-                      , pat_arg_tys = tys-                      , pat_wrap = idHsWrapper }+  = noLoc $ ConPat { pat_con = noLoc (RealDataCon dc)+                   , pat_args = PrefixCon pats+                   , pat_con_ext = ConPatTc+                     { cpt_tvs = []+                     , cpt_dicts = []+                     , cpt_binds = emptyTcEvBinds+                     , cpt_arg_tys = tys+                     , cpt_wrap = idHsWrapper+                     }+                   } -mkNilPat :: Type -> OutPat (GhcPass p)+mkNilPat :: Type -> LPat GhcTc mkNilPat ty = mkPrefixConPat nilDataCon [] [ty] -mkCharLitPat :: SourceText -> Char -> OutPat (GhcPass p)+mkCharLitPat :: SourceText -> Char -> LPat GhcTc mkCharLitPat src c = mkPrefixConPat charDataCon                           [noLoc $ LitPat noExtField (HsCharPrim src c)] [] @@ -685,7 +732,7 @@ looksLazyPat (WildPat {})  = False looksLazyPat _             = True -isIrrefutableHsPat :: (OutputableBndrId p) => LPat (GhcPass p) -> Bool+isIrrefutableHsPat :: forall p. (OutputableBndrId p) => LPat (GhcPass p) -> Bool -- (isIrrefutableHsPat p) is true if matching against p cannot fail, -- in the sense of falling through to the next pattern. --      (NB: this is not quite the same as the (silly) defn@@ -701,13 +748,14 @@ isIrrefutableHsPat   = goL   where+    goL :: LPat (GhcPass p) -> Bool     goL = go . unLoc +    go :: Pat (GhcPass p) -> Bool     go (WildPat {})        = True     go (VarPat {})         = True     go (LazyPat {})        = True     go (BangPat _ pat)     = goL pat-    go (CoPat _ _ pat _)   = go  pat     go (ParPat _ pat)      = goL pat     go (AsPat _ _ pat)     = goL pat     go (ViewPat _ _ pat)   = goL pat@@ -717,18 +765,19 @@                     -- See Note [Unboxed sum patterns aren't irrefutable]     go (ListPat {})        = False -    go (ConPatIn {})       = False     -- Conservative-    go (ConPatOut-        { pat_con  = L _ (RealDataCon con)+    go (ConPat+        { pat_con  = con         , pat_args = details })-                           =-      isJust (tyConSingleDataCon_maybe (dataConTyCon con))-      -- NB: tyConSingleDataCon_maybe, *not* isProductTyCon, because-      -- the latter is false of existentials. See #4439-      && all goL (hsConPatArgs details)-    go (ConPatOut-        { pat_con = L _ (PatSynCon _pat) })-                           = False -- Conservative+                           = case ghcPass @p of+       GhcPs -> False -- Conservative+       GhcRn -> False -- Conservative+       GhcTc -> case con of+         L _ (PatSynCon _pat)  -> False -- Conservative+         L _ (RealDataCon con) ->+           isJust (tyConSingleDataCon_maybe (dataConTyCon con))+           -- NB: tyConSingleDataCon_maybe, *not* isProductTyCon, because+           -- the latter is false of existentials. See #4439+           && all goL (hsConPatArgs details)     go (LitPat {})         = False     go (NPat {})           = False     go (NPlusKPat {})      = False@@ -737,7 +786,13 @@     -- since we cannot know until the splice is evaluated.     go (SplicePat {})      = False -    go (XPat nec)          = noExtCon nec+    go (XPat ext)          = case ghcPass @p of+#if __GLASGOW_HASKELL__ < 811+      GhcPs -> noExtCon ext+      GhcRn -> noExtCon ext+#endif+      GhcTc -> go pat+        where CoPat _ pat _ = ext  -- | Is the pattern any of combination of: --@@ -780,16 +835,21 @@  -- | @'patNeedsParens' p pat@ returns 'True' if the pattern @pat@ needs -- parentheses under precedence @p@.-patNeedsParens :: PprPrec -> Pat p -> Bool+patNeedsParens :: forall p. IsPass p => PprPrec -> Pat (GhcPass p) -> Bool patNeedsParens p = go   where+    go :: Pat (GhcPass p) -> Bool     go (NPlusKPat {})    = p > opPrec     go (SplicePat {})    = False-    go (ConPatIn _ ds)   = conPatNeedsParens p ds-    go cp@(ConPatOut {}) = conPatNeedsParens p (pat_args cp)+    go (ConPat { pat_args = ds})+                         = conPatNeedsParens p ds     go (SigPat {})       = p >= sigPrec     go (ViewPat {})      = True-    go (CoPat _ _ p _)   = go p+    go (XPat ext)        = case ghcPass @p of+      GhcPs -> noExtCon ext+      GhcRn -> noExtCon ext+      GhcTc -> go inner+        where CoPat _ inner _ = ext     go (WildPat {})      = False     go (VarPat {})       = False     go (LazyPat {})      = False@@ -801,7 +861,6 @@     go (ListPat {})      = False     go (LitPat _ l)      = hsLitNeedsParens p l     go (NPat _ lol _ _)  = hsOverLitNeedsParens p (unLoc lol)-    go (XPat {})         = True -- conservative default  -- | @'conPatNeedsParens' p cp@ returns 'True' if the constructor patterns @cp@ -- needs parentheses under precedence @p@.@@ -814,7 +873,10 @@  -- | @'parenthesizePat' p pat@ checks if @'patNeedsParens' p pat@ is true, and -- if so, surrounds @pat@ with a 'ParPat'. Otherwise, it simply returns @pat@.-parenthesizePat :: PprPrec -> LPat (GhcPass p) -> LPat (GhcPass p)+parenthesizePat :: IsPass p+                => PprPrec+                -> LPat (GhcPass p)+                -> LPat (GhcPass p) parenthesizePat p lpat@(L loc pat)   | patNeedsParens p pat = L loc (ParPat noExtField lpat)   | otherwise            = lpat@@ -840,12 +902,16 @@     ListPat _ ps     -> unionManyBags $ map collectEvVarsLPat ps     TuplePat _ ps _  -> unionManyBags $ map collectEvVarsLPat ps     SumPat _ p _ _   -> collectEvVarsLPat p-    ConPatOut {pat_dicts = dicts, pat_args  = args}+    ConPat+      { pat_args  = args+      , pat_con_ext = ConPatTc+        { cpt_dicts = dicts+        }+      }                      -> unionBags (listToBag dicts)                                    $ unionManyBags                                    $ map collectEvVarsLPat                                    $ hsConPatArgs args     SigPat  _ p _    -> collectEvVarsLPat p-    CoPat _ _ p _    -> collectEvVarsPat  p-    ConPatIn _  _    -> panic "foldMapPatBag: ConPatIn"+    XPat (CoPat _ p _) -> collectEvVarsPat  p     _other_pat       -> emptyBag
compiler/GHC/Hs/Pat.hs-boot view
@@ -9,7 +9,7 @@  module GHC.Hs.Pat where -import Outputable+import GHC.Utils.Outputable import GHC.Hs.Extension ( OutputableBndrId, GhcPass, XRec ) import Data.Kind
compiler/GHC/Hs/Types.hs view
@@ -72,7 +72,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Hs.Expr ( HsSplice, pprSplice ) @@ -83,15 +83,15 @@ import GHC.Types.Name.Reader ( RdrName ) import GHC.Core.DataCon( HsSrcBang(..), HsImplBang(..),                          SrcStrictness(..), SrcUnpackedness(..) )-import TysWiredIn( mkTupleStr )+import GHC.Builtin.Types( mkTupleStr ) import GHC.Core.Type import GHC.Hs.Doc import GHC.Types.Basic import GHC.Types.SrcLoc-import Outputable-import FastString-import Maybes( isJust )-import Util ( count )+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Data.Maybe( isJust )+import GHC.Utils.Misc ( count )  import Data.Data hiding ( Fixity, Prefix, Infix ) @@ -143,7 +143,7 @@ renamer can decorate it with the variables bound by the pattern ('a' in the first example, 'k' in the second), assuming that neither of them is in scope already-See also Note [Kind and type-variable binders] in GHC.Rename.Types+See also Note [Kind and type-variable binders] in GHC.Rename.HsType  Note [HsType binders] ~~~~~~~~~~~~~~~~~~~~~@@ -231,7 +231,7 @@   determine whether or not to emit hole constraints on each wildcard   (we don't if it's a visible type/kind argument or a type family pattern).   See related notes Note [Wildcards in visible kind application]-  and Note [Wildcards in visible type application] in TcHsType.hs+  and Note [Wildcards in visible type application] in GHC.Tc.Gen.HsType  * After type checking is done, we report what types the wildcards   got unified with.@@ -264,7 +264,7 @@ preserve their existing left-to-right ordering.  Implicitly bound variables are collected by the extract- family of functions-(extractHsTysRdrTyVars, extractHsTyVarBndrsKVs, etc.) in GHC.Rename.Types.+(extractHsTysRdrTyVars, extractHsTyVarBndrsKVs, etc.) in GHC.Rename.HsType. These functions thus promise to keep left-to-right ordering. Look for pointers to this note to see the places where the action happens. @@ -284,7 +284,7 @@ -- | Located Haskell Context type LHsContext pass = Located (HsContext pass)       -- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnUnit'-      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation  noLHsContext :: LHsContext pass -- Use this when there is no context in the original program@@ -302,7 +302,7 @@       -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when       --   in a list -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Haskell Kind type HsKind pass = HsType pass@@ -311,7 +311,7 @@ type LHsKind pass = Located (HsKind pass)       -- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation  -------------------------------------------------- --             LHsQTyVars@@ -328,7 +328,7 @@            , hsq_explicit :: [LHsTyVarBndr pass]                 -- Explicit variables, written by the user     }-  | XLHsQTyVars (XXLHsQTyVars pass)+  | XLHsQTyVars !(XXLHsQTyVars pass)  type HsQTvsRn = [Name]  -- Implicit variables   -- For example, in   data T (a :: k1 -> k2) = ...@@ -352,7 +352,6 @@ isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool isEmptyLHsQTvs (HsQTvs { hsq_ext = imp, hsq_explicit = exp })   = null imp && null exp-isEmptyLHsQTvs _ = False  ------------------------------------------------ --            HsImplicitBndrs@@ -366,11 +365,11 @@                                          -- Implicitly-bound kind & type vars                                          -- Order is important; see                                          -- Note [Ordering of implicit variables]-                                         -- in GHC.Rename.Types+                                         -- in GHC.Rename.HsType           , hsib_body :: thing            -- Main payload (type or list of types)     }-  | XHsImplicitBndrs (XXHsImplicitBndrs pass thing)+  | XHsImplicitBndrs !(XXHsImplicitBndrs pass thing)  type instance XHsIB              GhcPs _ = NoExtField type instance XHsIB              GhcRn _ = [Name]@@ -392,7 +391,7 @@                 -- If there is an extra-constraints wildcard,                 -- it's still there in the hsc_body.     }-  | XHsWildCardBndrs (XXHsWildCardBndrs pass thing)+  | XHsWildCardBndrs !(XXHsWildCardBndrs pass thing)  type instance XHsWC              GhcPs b = NoExtField type instance XHsWC              GhcRn b = [Name]@@ -413,7 +412,6 @@  hsImplicitBody :: HsImplicitBndrs (GhcPass p) thing -> thing hsImplicitBody (HsIB { hsib_body = body }) = body-hsImplicitBody (XHsImplicitBndrs nec) = noExtCon nec  hsSigType :: LHsSigType (GhcPass p) -> LHsType (GhcPass p) hsSigType = hsImplicitBody@@ -497,10 +495,10 @@         --  - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',         --          'ApiAnnotation.AnnDcolon', 'ApiAnnotation.AnnClose' -        -- For details on above see note [Api annotations] in ApiAnnotation+        -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | XTyVarBndr-      (XXTyVarBndr pass)+      !(XXTyVarBndr pass)  type instance XUserTyVar    (GhcPass _) = NoExtField type instance XKindedTyVar  (GhcPass _) = NoExtField@@ -520,7 +518,6 @@ instance NamedThing (HsTyVarBndr GhcRn) where   getName (UserTyVar _ v) = unLoc v   getName (KindedTyVar _ v _) = unLoc v-  getName (XTyVarBndr nec) = noExtCon nec  -- | Haskell Type data HsType pass@@ -534,7 +531,7 @@       }       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnForall',       --         'ApiAnnotation.AnnDot','ApiAnnotation.AnnDarrow'-      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsQualTy   -- See Note [HsType binders]       { hst_xqual :: XQualTy pass@@ -550,14 +547,14 @@                   -- See Note [Located RdrNames] in GHC.Hs.Expr       -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsAppTy             (XAppTy pass)                         (LHsType pass)                         (LHsType pass)       -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsAppKindTy         (XAppKindTy pass) -- type level type app                         (LHsType pass)@@ -568,14 +565,14 @@                         (LHsType pass)       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow', -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsListTy            (XListTy pass)                         (LHsType pass)  -- Element type       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@,       --         'ApiAnnotation.AnnClose' @']'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsTupleTy           (XTupleTy pass)                         HsTupleSort@@ -583,30 +580,30 @@     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'(' or '(#'@,     --         'ApiAnnotation.AnnClose' @')' or '#)'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsSumTy             (XSumTy pass)                         [LHsType pass]  -- Element types (length gives arity)     -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'(#'@,     --         'ApiAnnotation.AnnClose' '#)'@ -    -- For details on above see note [Api annotations] in ApiAnnotation+    -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsOpTy              (XOpTy pass)                         (LHsType pass) (Located (IdP pass)) (LHsType pass)       -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsParTy             (XParTy pass)                         (LHsType pass)   -- See Note [Parens in HsSyn] in GHC.Hs.Expr         -- Parenthesis preserved for the precedence re-arrangement in-        -- GHC.Rename.Types+        -- GHC.Rename.HsType         -- It's important that a * (b + c) doesn't get rearranged to (a*b) + c!       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,       --         'ApiAnnotation.AnnClose' @')'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsIParamTy          (XIParamTy pass)                         (Located HsIPName) -- (?x :: ty)@@ -617,7 +614,7 @@       --       -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsStarTy            (XStarTy pass)                         Bool             -- Is this the Unicode variant?@@ -633,20 +630,20 @@       -- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,       --         'ApiAnnotation.AnnDcolon','ApiAnnotation.AnnClose' @')'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsSpliceTy          (XSpliceTy pass)                         (HsSplice pass)   -- Includes quasi-quotes       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'$('@,       --         'ApiAnnotation.AnnClose' @')'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsDocTy             (XDocTy pass)                         (LHsType pass) LHsDocString -- A documented type       -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsBangTy    (XBangTy pass)                 HsSrcBang (LHsType pass)   -- Bang-style type annotations@@ -655,20 +652,20 @@       --         'ApiAnnotation.AnnClose' @'#-}'@       --         'ApiAnnotation.AnnBang' @\'!\'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsRecTy     (XRecTy pass)                 [LConDeclField pass]    -- Only in data type declarations       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@,       --         'ApiAnnotation.AnnClose' @'}'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    -- | HsCoreTy (XCoreTy pass) Type -- An escape hatch for tunnelling a *closed*   --                                -- Core Type through HsSyn.   --     -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsExplicitListTy       -- A promoted explicit list         (XExplicitListTy pass)@@ -677,7 +674,7 @@       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @"'["@,       --         'ApiAnnotation.AnnClose' @']'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsExplicitTupleTy      -- A promoted explicit tuple         (XExplicitTupleTy pass)@@ -685,18 +682,18 @@       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @"'("@,       --         'ApiAnnotation.AnnClose' @')'@ -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsTyLit (XTyLit pass) HsTyLit      -- A promoted numeric literal.       -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    | HsWildCardTy (XWildCardTy pass)  -- A type wildcard       -- See Note [The wildcard story for types]       -- ^ - 'ApiAnnotation.AnnKeywordId' : None -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation    -- For adding new constructors via Trees that Grow   | XHsType@@ -860,7 +857,7 @@       -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when       --   in a list -      -- For details on above see note [Api annotations] in ApiAnnotation+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation  -- | Constructor Declaration Field data ConDeclField pass  -- Record fields have Haddock docs on them@@ -871,8 +868,8 @@                    cd_fld_doc  :: Maybe LHsDocString }       -- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon' -      -- For details on above see note [Api annotations] in ApiAnnotation-  | XConDeclField (XXConDeclField pass)+      -- For details on above see note [Api annotations] in GHC.Parser.Annotation+  | XConDeclField !(XXConDeclField pass)  type instance XConDeclField  (GhcPass _) = NoExtField type instance XXConDeclField (GhcPass _) = NoExtCon@@ -880,7 +877,6 @@ instance OutputableBndrId p        => Outputable (ConDeclField (GhcPass p)) where   ppr (ConDeclField _ fld_n fld_ty _) = ppr fld_n <+> dcolon <+> ppr fld_ty-  ppr (XConDeclField x) = ppr x  -- HsConDetails is used for patterns/expressions *and* for data type -- declarations@@ -944,8 +940,6 @@                       , hst_bndrs = tvs }) ->         vars ++ nwcs ++ hsLTyVarNames tvs       _                                    -> nwcs-hsWcScopedTvs (HsWC _ (XHsImplicitBndrs nec)) = noExtCon nec-hsWcScopedTvs (XHsWildCardBndrs nec) = noExtCon nec  hsScopedTvs :: LHsSigType GhcRn -> [Name] -- Same as hsWcScopedTvs, but for a LHsSigType@@ -1013,7 +1007,7 @@  If we do not pattern-match on ForallInvis in hsScopedTvs, then `a` would erroneously be brought into scope over the body of `x` when renaming it.-Although the typechecker would later reject this (see `TcValidity.vdqAllowed`),+Although the typechecker would later reject this (see `GHC.Tc.Validity.vdqAllowed`), it is still possible for this to wreak havoc in the renamer before it gets to that point (see #17687 for an example of this). Bottom line: nip problems in the bud by matching on ForallInvis from the start.@@ -1023,7 +1017,6 @@ hsTyVarName :: HsTyVarBndr (GhcPass p) -> IdP (GhcPass p) hsTyVarName (UserTyVar _ (L _ n))     = n hsTyVarName (KindedTyVar _ (L _ n) _) = n-hsTyVarName (XTyVarBndr nec) = noExtCon nec  hsLTyVarName :: LHsTyVarBndr (GhcPass p) -> IdP (GhcPass p) hsLTyVarName = hsTyVarName . unLoc@@ -1040,7 +1033,6 @@ hsAllLTyVarNames (HsQTvs { hsq_ext = kvs                          , hsq_explicit = tvs })   = kvs ++ hsLTyVarNames tvs-hsAllLTyVarNames (XLHsQTyVars nec) = noExtCon nec  hsLTyVarLocName :: LHsTyVarBndr (GhcPass p) -> Located (IdP (GhcPass p)) hsLTyVarLocName = mapLoc hsTyVarName@@ -1051,17 +1043,16 @@ -- | Convert a LHsTyVarBndr to an equivalent LHsType. hsLTyVarBndrToType :: LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p) hsLTyVarBndrToType = mapLoc cvt-  where cvt (UserTyVar _ n) = HsTyVar noExtField NotPromoted n+  where cvt :: HsTyVarBndr (GhcPass p) -> HsType (GhcPass p)+        cvt (UserTyVar _ n) = HsTyVar noExtField NotPromoted n         cvt (KindedTyVar _ (L name_loc n) kind)           = HsKindSig noExtField                    (L name_loc (HsTyVar noExtField NotPromoted (L name_loc n))) kind-        cvt (XTyVarBndr nec) = noExtCon nec  -- | Convert a LHsTyVarBndrs to a list of types. -- Works on *type* variable only, no kind vars. hsLTyVarBndrsToTypes :: LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)] hsLTyVarBndrsToTypes (HsQTvs { hsq_explicit = tvbs }) = map hsLTyVarBndrToType tvbs-hsLTyVarBndrsToTypes (XLHsQTyVars nec) = noExtCon nec  -- | Get the kind signature of a type, ignoring parentheses: --@@ -1282,7 +1273,6 @@   = (itkvs ++ hsLTyVarNames tvs, cxt, body_ty)          -- Return implicitly bound type and kind vars          -- For an instance decl, all of them are in scope-splitLHsInstDeclTy (XHsImplicitBndrs nec) = noExtCon nec  getLHsInstDeclHead :: LHsSigType (GhcPass p) -> LHsType (GhcPass p) getLHsInstDeclHead inst_ty@@ -1319,7 +1309,7 @@                               }    | XFieldOcc-      (XXFieldOcc pass)+      !(XXFieldOcc pass) deriving instance Eq  (XCFieldOcc (GhcPass p)) => Eq  (FieldOcc (GhcPass p))  type instance XCFieldOcc GhcPs = NoExtField@@ -1345,12 +1335,12 @@ -- occurrences). -- -- See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat and--- Note [Disambiguating record fields] in TcExpr.+-- Note [Disambiguating record fields] in GHC.Tc.Gen.Expr. -- See Note [Located RdrNames] in GHC.Hs.Expr data AmbiguousFieldOcc pass   = Unambiguous (XUnambiguous pass) (Located RdrName)   | Ambiguous   (XAmbiguous pass)   (Located RdrName)-  | XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)+  | XAmbiguousFieldOcc !(XXAmbiguousFieldOcc pass)  type instance XUnambiguous GhcPs = NoExtField type instance XUnambiguous GhcRn = Name@@ -1375,23 +1365,17 @@ rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc (GhcPass p) -> RdrName rdrNameAmbiguousFieldOcc (Unambiguous _ (L _ rdr)) = rdr rdrNameAmbiguousFieldOcc (Ambiguous   _ (L _ rdr)) = rdr-rdrNameAmbiguousFieldOcc (XAmbiguousFieldOcc nec)-  = noExtCon nec  selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id selectorAmbiguousFieldOcc (Unambiguous sel _) = sel selectorAmbiguousFieldOcc (Ambiguous   sel _) = sel-selectorAmbiguousFieldOcc (XAmbiguousFieldOcc nec)-  = noExtCon nec  unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc unambiguousFieldOcc (Unambiguous rdr sel) = FieldOcc rdr sel unambiguousFieldOcc (Ambiguous   rdr sel) = FieldOcc rdr sel-unambiguousFieldOcc (XAmbiguousFieldOcc nec) = noExtCon nec  ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc ambiguousFieldOcc (FieldOcc sel rdr) = Unambiguous sel rdr-ambiguousFieldOcc (XFieldOcc nec) = noExtCon nec  {- ************************************************************************@@ -1410,23 +1394,19 @@ instance OutputableBndrId p        => Outputable (LHsQTyVars (GhcPass p)) where     ppr (HsQTvs { hsq_explicit = tvs }) = interppSP tvs-    ppr (XLHsQTyVars x) = ppr x  instance OutputableBndrId p        => Outputable (HsTyVarBndr (GhcPass p)) where     ppr (UserTyVar _ n)     = ppr n     ppr (KindedTyVar _ n k) = parens $ hsep [ppr n, dcolon, ppr k]-    ppr (XTyVarBndr nec)    = noExtCon nec  instance Outputable thing        => Outputable (HsImplicitBndrs (GhcPass p) thing) where     ppr (HsIB { hsib_body = ty }) = ppr ty-    ppr (XHsImplicitBndrs x) = ppr x  instance Outputable thing        => Outputable (HsWildCardBndrs (GhcPass p) thing) where     ppr (HsWC { hswc_body = ty }) = ppr ty-    ppr (XHsWildCardBndrs x) = ppr x  pprAnonWildCard :: SDoc pprAnonWildCard = char '_'
compiler/GHC/Hs/Utils.hs view
@@ -9,9 +9,9 @@     Parameterised by          Module    ----------------          --------------   GhcPs/RdrName             parser/RdrHsSyn-   GhcRn/Name                rename/RnHsSyn-   GhcTc/Id                  typecheck/TcHsSyn+   GhcPs/RdrName             GHC.Parser.PostProcess+   GhcRn/Name                GHC.Rename.*+   GhcTc/Id                  GHC.Tc.Utils.Zonk  The @mk*@ functions attempt to construct a not-completely-useless SrcSpan from their components, compared with the @nl*@ functions which@@ -24,6 +24,9 @@ {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleInstances #-}  {-# OPTIONS_GHC -Wno-incomplete-record-updates #-} @@ -69,7 +72,8 @@   nlHsAppTy, nlHsAppKindTy, nlHsTyVar, nlHsFunTy, nlHsParTy, nlHsTyConApp,    -- * Stmts-  mkTransformStmt, mkTransformByStmt, mkBodyStmt, mkBindStmt, mkTcBindStmt,+  mkTransformStmt, mkTransformByStmt, mkBodyStmt,+  mkPsBindStmt, mkRnBindStmt, mkTcBindStmt,   mkLastStmt,   emptyTransStmt, mkGroupUsingStmt, mkGroupByUsingStmt,   emptyRecStmt, emptyRecStmtName, emptyRecStmtId, mkRecStmt,@@ -88,6 +92,7 @@   collectPatBinders, collectPatsBinders,   collectLStmtsBinders, collectStmtsBinders,   collectLStmtBinders, collectStmtBinders,+  CollectPass(..),    hsLTyClDeclBinders, hsTyClForeignBinders,   hsPatSynSelectors, getPatSynBinds,@@ -99,7 +104,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Hs.Decls import GHC.Hs.Binds@@ -109,13 +114,14 @@ import GHC.Hs.Lit import GHC.Hs.Extension -import TcEvidence+import GHC.Tc.Types.Evidence import GHC.Types.Name.Reader import GHC.Types.Var import GHC.Core.TyCo.Rep+import GHC.Core.TyCon import GHC.Core.Type ( appTyArgFlags, splitAppTys, tyConArgFlags, tyConAppNeedsKindSig )-import TysWiredIn ( unitTy )-import TcType+import GHC.Builtin.Types ( unitTy )+import GHC.Tc.Utils.TcType import GHC.Core.DataCon import GHC.Core.ConLike import GHC.Types.Id@@ -124,15 +130,16 @@ import GHC.Types.Name.Env import GHC.Types.Basic import GHC.Types.SrcLoc-import FastString-import Util-import Bag-import Outputable-import Constants+import GHC.Data.FastString+import GHC.Utils.Misc+import GHC.Data.Bag+import GHC.Utils.Outputable+import GHC.Settings.Constants  import Data.Either import Data.Function import Data.List+import Data.Proxy  {- ************************************************************************@@ -185,8 +192,7 @@ mkHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) mkHsApp e1 e2 = addCLoc e1 e2 (HsApp noExtField e1 e2) -mkHsAppType :: (NoGhcTc (GhcPass id) ~ GhcRn)-            => LHsExpr (GhcPass id) -> LHsWcType GhcRn -> LHsExpr (GhcPass id)+mkHsAppType :: LHsExpr GhcRn -> LHsWcType GhcRn -> LHsExpr GhcRn mkHsAppType e t = addCLoc e t_body (HsAppType noExtField e paren_wct)   where     t_body    = hswc_body t@@ -195,8 +201,11 @@ mkHsAppTypes :: LHsExpr GhcRn -> [LHsWcType GhcRn] -> LHsExpr GhcRn mkHsAppTypes = foldl' mkHsAppType -mkHsLam :: (XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ NoExtField) =>-  [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)+mkHsLam :: IsPass p+        => (XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ NoExtField)+        => [LPat (GhcPass p)]+        -> LHsExpr (GhcPass p)+        -> LHsExpr (GhcPass p) mkHsLam pats body = mkHsPar (L (getLoc body) (HsLam noExtField matches))   where     matches = mkMatchGroup Generated@@ -229,7 +238,7 @@   | hsExprNeedsParens appPrec e = L loc (HsPar noExtField le)   | otherwise                   = le -mkParPat :: LPat (GhcPass name) -> LPat (GhcPass name)+mkParPat :: IsPass p => LPat (GhcPass p) -> LPat (GhcPass p) mkParPat lp@(L loc p)   | patNeedsParens appPrec p = L loc (ParPat noExtField lp)   | otherwise                = lp@@ -258,10 +267,10 @@            -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) mkBodyStmt :: Located (bodyR GhcPs)            -> StmtLR (GhcPass idL) GhcPs (Located (bodyR GhcPs))-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)))+mkPsBindStmt :: LPat GhcPs -> Located (bodyR GhcPs)+             -> StmtLR GhcPs GhcPs (Located (bodyR GhcPs))+mkRnBindStmt :: LPat GhcRn -> Located (bodyR GhcRn)+             -> StmtLR GhcRn GhcRn (Located (bodyR GhcRn)) mkTcBindStmt :: LPat GhcTc -> Located (bodyR GhcTc)              -> StmtLR GhcTc GhcTc (Located (bodyR GhcTc)) @@ -319,9 +328,9 @@ mkLastStmt body = LastStmt noExtField body Nothing noSyntaxExpr mkBodyStmt body   = BodyStmt noExtField body noSyntaxExpr noSyntaxExpr-mkBindStmt pat body-  = BindStmt noExtField pat body noSyntaxExpr noSyntaxExpr-mkTcBindStmt pat body = BindStmt unitTy pat body noSyntaxExpr noSyntaxExpr+mkPsBindStmt pat body = BindStmt noExtField pat body+mkRnBindStmt pat body = BindStmt (XBindStmtRn { xbsrn_bindOp = noSyntaxExpr, xbsrn_failOp = Nothing }) pat body+mkTcBindStmt pat body = BindStmt (XBindStmtTc { xbstc_bindOp = noSyntaxExpr, xbstc_boundResultType =unitTy, xbstc_failOp = Nothing }) pat body   -- don't use placeHolderTypeTc above, because that panics during zonking  emptyRecStmt' :: forall idL idR body. IsPass idR@@ -434,25 +443,42 @@ nlConVarPatName con vars = nlConPatName con (map nlVarPat vars)  nlInfixConPat :: RdrName -> LPat GhcPs -> LPat GhcPs -> LPat GhcPs-nlInfixConPat con l r = noLoc (ConPatIn (noLoc con)-                              (InfixCon (parenthesizePat opPrec l)-                                        (parenthesizePat opPrec r)))+nlInfixConPat con l r = noLoc $ ConPat+  { pat_con = noLoc con+  , pat_args = InfixCon (parenthesizePat opPrec l)+                        (parenthesizePat opPrec r)+  , pat_con_ext = noExtField+  }  nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs-nlConPat con pats =-  noLoc (ConPatIn (noLoc con) (PrefixCon (map (parenthesizePat appPrec) pats)))+nlConPat con pats = noLoc $ ConPat+  { pat_con_ext = noExtField+  , pat_con = noLoc con+  , pat_args = PrefixCon (map (parenthesizePat appPrec) pats)+  }  nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn-nlConPatName con pats =-  noLoc (ConPatIn (noLoc con) (PrefixCon (map (parenthesizePat appPrec) pats)))+nlConPatName con pats = noLoc $ ConPat+  { pat_con_ext = noExtField+  , pat_con = noLoc con+  , pat_args = PrefixCon (map (parenthesizePat appPrec) pats)+  } -nlNullaryConPat :: IdP (GhcPass p) -> LPat (GhcPass p)-nlNullaryConPat con = noLoc (ConPatIn (noLoc con) (PrefixCon []))+nlNullaryConPat :: RdrName -> LPat GhcPs+nlNullaryConPat con = noLoc $ ConPat+  { pat_con_ext = noExtField+  , pat_con = noLoc con+  , pat_args = PrefixCon []+  }  nlWildConPat :: DataCon -> LPat GhcPs-nlWildConPat con = noLoc (ConPatIn (noLoc (getRdrName con))-                         (PrefixCon (replicate (dataConSourceArity con)-                                             nlWildPat)))+nlWildConPat con = noLoc $ ConPat+  { pat_con_ext = noExtField+  , pat_con = noLoc $ getRdrName con+  , pat_args = PrefixCon $+     replicate (dataConSourceArity con)+               nlWildPat+  }  -- | Wildcard pattern - after parsing nlWildPat :: LPat GhcPs@@ -686,7 +712,11 @@       | otherwise = ty'        where         ty' :: LHsType GhcPs-        ty' = go_app (nlHsTyVar (getRdrName tc)) args (tyConArgFlags tc args)+        ty' = go_app (noLoc $ HsTyVar noExtField prom $ noLoc $ getRdrName tc)+                     args (tyConArgFlags tc args)++        prom :: PromotionFlag+        prom = if isPromotedDataCon tc then IsPromoted else NotPromoted     go ty@(AppTy {})        = go_app (go head) args (appTyArgFlags head args)       where         head :: Type@@ -795,11 +825,11 @@  mkHsWrapPat :: HsWrapper -> Pat GhcTc -> Type -> Pat GhcTc mkHsWrapPat co_fn p ty | isIdHsWrapper co_fn = p-                       | otherwise           = CoPat noExtField co_fn p ty+                       | otherwise           = XPat $ CoPat co_fn p ty  mkHsWrapPatCo :: TcCoercionN -> Pat GhcTc -> Type -> Pat GhcTc mkHsWrapPatCo co pat ty | isTcReflCo co = pat-                        | otherwise    = CoPat noExtField (mkWpCastN co) pat ty+                        | otherwise     = XPat $ CoPat (mkWpCastN co) pat ty  mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc mkHsDictLet ev_binds expr = mkLHsWrap (mkWpLet ev_binds) expr@@ -874,8 +904,10 @@                           , mc_strictness = NoSrcStrict }  -------------mkMatch :: HsMatchContext (NoGhcTc (GhcPass p))-        -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p)+mkMatch :: forall p. IsPass p+        => HsMatchContext (NoGhcTc (GhcPass p))+        -> [LPat (GhcPass p)]+        -> LHsExpr (GhcPass p)         -> Located (HsLocalBinds (GhcPass p))         -> LMatch (GhcPass p) (LHsExpr (GhcPass p)) mkMatch ctxt pats expr lbinds@@ -884,6 +916,7 @@                  , m_pats  = map paren pats                  , m_grhss = GRHSs noExtField (unguardedRHS noSrcSpan expr) lbinds })   where+    paren :: Located (Pat (GhcPass p)) -> Located (Pat (GhcPass p))     paren lp@(L l p)       | patNeedsParens appPrec p = L l (ParPat noExtField lp)       | otherwise                = lp@@ -973,57 +1006,76 @@ isBangedHsBind _   = False -collectLocalBinders :: HsLocalBindsLR (GhcPass idL) (GhcPass idR)+collectLocalBinders :: CollectPass (GhcPass idL)+                    => HsLocalBindsLR (GhcPass idL) (GhcPass idR)                     -> [IdP (GhcPass idL)] collectLocalBinders (HsValBinds _ binds) = collectHsIdBinders binds                                          -- No pattern synonyms here collectLocalBinders (HsIPBinds {})      = [] collectLocalBinders (EmptyLocalBinds _) = []-collectLocalBinders (XHsLocalBindsLR _) = [] -collectHsIdBinders, collectHsValBinders-  :: HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]+collectHsIdBinders :: CollectPass (GhcPass idL)+                   => HsValBindsLR (GhcPass idL) (GhcPass idR)+                   -> [IdP (GhcPass idL)] -- ^ Collect 'Id' binders only, or 'Id's + pattern synonyms, respectively collectHsIdBinders  = collect_hs_val_binders True++collectHsValBinders :: CollectPass (GhcPass idL)+                    => HsValBindsLR (GhcPass idL) (GhcPass idR)+                    -> [IdP (GhcPass idL)] collectHsValBinders = collect_hs_val_binders False -collectHsBindBinders :: XRec pass Pat ~ Located (Pat pass) =>-                        HsBindLR pass idR -> [IdP pass]+collectHsBindBinders :: CollectPass p+                     => HsBindLR p idR+                     -> [IdP p] -- ^ Collect both 'Id's and pattern-synonym binders collectHsBindBinders b = collect_bind False b [] -collectHsBindsBinders :: LHsBindsLR (GhcPass p) idR -> [IdP (GhcPass p)]+collectHsBindsBinders :: CollectPass p+                      => LHsBindsLR p idR+                      -> [IdP p] collectHsBindsBinders binds = collect_binds False binds [] -collectHsBindListBinders :: [LHsBindLR (GhcPass p) idR] -> [IdP (GhcPass p)]+collectHsBindListBinders :: CollectPass p+                         => [LHsBindLR p idR]+                         -> [IdP p] -- ^ Same as 'collectHsBindsBinders', but works over a list of bindings collectHsBindListBinders = foldr (collect_bind False . unLoc) [] -collect_hs_val_binders :: Bool -> HsValBindsLR (GhcPass idL) (GhcPass idR)+collect_hs_val_binders :: CollectPass (GhcPass idL)+                       => Bool+                       -> HsValBindsLR (GhcPass idL) (GhcPass idR)                        -> [IdP (GhcPass idL)] collect_hs_val_binders ps (ValBinds _ binds _) = collect_binds ps binds [] collect_hs_val_binders ps (XValBindsLR (NValBinds binds _))   = collect_out_binds ps binds -collect_out_binds :: Bool -> [(RecFlag, LHsBinds (GhcPass p))] ->-                     [IdP (GhcPass p)]+collect_out_binds :: CollectPass p+                  => Bool+                  -> [(RecFlag, LHsBinds p)]+                  -> [IdP p] collect_out_binds ps = foldr (collect_binds ps . snd) [] -collect_binds :: Bool -> LHsBindsLR (GhcPass p) idR ->-                 [IdP (GhcPass p)] -> [IdP (GhcPass p)]+collect_binds :: CollectPass p+              => Bool+              -> LHsBindsLR p idR+              -> [IdP p]+              -> [IdP p] -- ^ Collect 'Id's, or 'Id's + pattern synonyms, depending on boolean flag collect_binds ps binds acc = foldr (collect_bind ps . unLoc) acc binds -collect_bind :: XRec pass Pat ~ Located (Pat pass) =>-                Bool -> HsBindLR pass idR ->-                [IdP pass] -> [IdP pass]+collect_bind :: CollectPass p+             => Bool+             -> HsBindLR p idR+             -> [IdP p]+             -> [IdP p] collect_bind _ (PatBind { pat_lhs = p })           acc = collect_lpat p acc collect_bind _ (FunBind { fun_id = L _ f })        acc = f : acc collect_bind _ (VarBind { var_id = f })            acc = f : acc collect_bind _ (AbsBinds { abs_exports = dbinds }) acc = map abe_poly dbinds ++ acc         -- I don't think we want the binders from the abe_binds -        -- binding (hence see AbsBinds) is in zonking in TcHsSyn+        -- binding (hence see AbsBinds) is in zonking in GHC.Tc.Utils.Zonk collect_bind omitPatSyn (PatSynBind _ (PSB { psb_id = L _ ps })) acc   | omitPatSyn                  = acc   | otherwise                   = ps : acc@@ -1040,22 +1092,26 @@        -- Someone else complains about non-FunBinds  ----------------- Statements ---------------------------collectLStmtsBinders :: [LStmtLR (GhcPass idL) (GhcPass idR) body]+collectLStmtsBinders :: (CollectPass (GhcPass idL))+                     => [LStmtLR (GhcPass idL) (GhcPass idR) body]                      -> [IdP (GhcPass idL)] collectLStmtsBinders = concatMap collectLStmtBinders -collectStmtsBinders :: [StmtLR (GhcPass idL) (GhcPass idR) body]+collectStmtsBinders :: (CollectPass (GhcPass idL))+                    => [StmtLR (GhcPass idL) (GhcPass idR) body]                     -> [IdP (GhcPass idL)] collectStmtsBinders = concatMap collectStmtBinders -collectLStmtBinders :: LStmtLR (GhcPass idL) (GhcPass idR) body+collectLStmtBinders :: (CollectPass (GhcPass idL))+                    => LStmtLR (GhcPass idL) (GhcPass idR) body                     -> [IdP (GhcPass idL)] collectLStmtBinders = collectStmtBinders . unLoc -collectStmtBinders :: StmtLR (GhcPass idL) (GhcPass idR) body+collectStmtBinders :: (CollectPass (GhcPass idL))+                   => StmtLR (GhcPass idL) (GhcPass idR) body                    -> [IdP (GhcPass idL)]   -- Id Binders for a Stmt... [but what about pattern-sig type vars]?-collectStmtBinders (BindStmt _ pat _ _ _)  = collectPatBinders pat+collectStmtBinders (BindStmt _ pat _)      = collectPatBinders pat collectStmtBinders (LetStmt _  binds)      = collectLocalBinders (unLoc binds) collectStmtBinders (BodyStmt {})           = [] collectStmtBinders (LastStmt {})           = []@@ -1067,50 +1123,66 @@  where   collectArgBinders (_, ApplicativeArgOne { app_arg_pattern = pat }) = collectPatBinders pat   collectArgBinders (_, ApplicativeArgMany { bv_pattern = pat }) = collectPatBinders pat-  collectArgBinders _ = []-collectStmtBinders (XStmtLR nec) = noExtCon nec+  collectArgBinders (_, XApplicativeArg {}) = []   ----------------- Patterns ---------------------------collectPatBinders :: LPat (GhcPass p) -> [IdP (GhcPass p)]+collectPatBinders :: CollectPass p => LPat p -> [IdP p] collectPatBinders pat = collect_lpat pat [] -collectPatsBinders :: [LPat (GhcPass p)] -> [IdP (GhcPass p)]+collectPatsBinders :: CollectPass p => [LPat p] -> [IdP p] collectPatsBinders pats = foldr collect_lpat [] pats  --------------collect_lpat :: XRec pass Pat ~ Located (Pat pass) =>-                LPat pass -> [IdP pass] -> [IdP pass]-collect_lpat p bndrs-  = go (unLoc p)-  where-    go (VarPat _ var)             = unLoc var : bndrs-    go (WildPat _)                = bndrs-    go (LazyPat _ pat)            = collect_lpat pat bndrs-    go (BangPat _ pat)            = collect_lpat pat bndrs-    go (AsPat _ a pat)            = unLoc a : collect_lpat pat bndrs-    go (ViewPat _ _ pat)          = collect_lpat pat bndrs-    go (ParPat _ pat)             = collect_lpat pat bndrs+collect_lpat :: forall pass. (CollectPass pass)+             => LPat pass -> [IdP pass] -> [IdP pass]+collect_lpat p bndrs = collect_pat (unLoc p) bndrs -    go (ListPat _ pats)           = foldr collect_lpat bndrs pats-    go (TuplePat _ pats _)        = foldr collect_lpat bndrs pats-    go (SumPat _ pat _ _)         = collect_lpat pat bndrs+collect_pat :: forall p. CollectPass p+            => Pat p+            -> [IdP p]+            -> [IdP p]+collect_pat pat bndrs = case pat of+  (VarPat _ var)          -> unLoc var : bndrs+  (WildPat _)             -> bndrs+  (LazyPat _ pat)         -> collect_lpat pat bndrs+  (BangPat _ pat)         -> collect_lpat pat bndrs+  (AsPat _ a pat)         -> unLoc a : collect_lpat pat bndrs+  (ViewPat _ _ pat)       -> collect_lpat pat bndrs+  (ParPat _ pat)          -> collect_lpat pat bndrs+  (ListPat _ pats)        -> foldr collect_lpat bndrs pats+  (TuplePat _ pats _)     -> foldr collect_lpat bndrs pats+  (SumPat _ pat _ _)      -> collect_lpat pat bndrs+  (ConPat {pat_args=ps})  -> foldr collect_lpat bndrs (hsConPatArgs ps)+  -- See Note [Dictionary binders in ConPatOut]+  (LitPat _ _)            -> bndrs+  (NPat {})               -> bndrs+  (NPlusKPat _ n _ _ _ _) -> unLoc n : bndrs+  (SigPat _ pat _)        -> collect_lpat pat bndrs+  (SplicePat _ (HsSpliced _ _ (HsSplicedPat pat)))+                          -> collect_pat pat bndrs+  (SplicePat _ _)         -> bndrs+  (XPat ext)              -> collectXXPat (Proxy @p) ext bndrs -    go (ConPatIn _ ps)            = foldr collect_lpat bndrs (hsConPatArgs ps)-    go (ConPatOut {pat_args=ps})  = foldr collect_lpat bndrs (hsConPatArgs ps)-        -- See Note [Dictionary binders in ConPatOut]-    go (LitPat _ _)               = bndrs-    go (NPat {})                  = bndrs-    go (NPlusKPat _ n _ _ _ _)    = unLoc n : bndrs+-- | This class specifies how to collect variable identifiers from extension patterns in the given pass.+-- Consumers of the GHC API that define their own passes should feel free to implement instances in order+-- to make use of functions which depend on it.+--+-- In particular, Haddock already makes use of this, with an instance for its 'DocNameI' pass so that+-- it can reuse the code in GHC for collecting binders.+class (XRec p Pat ~ Located (Pat p)) => CollectPass p where+  collectXXPat :: Proxy p -> XXPat p -> [IdP p] -> [IdP p] -    go (SigPat _ pat _)           = collect_lpat pat bndrs+instance CollectPass (GhcPass 'Parsed) where+  collectXXPat _ ext = noExtCon ext -    go (SplicePat _ (HsSpliced _ _ (HsSplicedPat pat)))-                                  = go pat-    go (SplicePat _ _)            = bndrs-    go (CoPat _ _ pat _)          = go pat-    go (XPat {})                  = bndrs+instance CollectPass (GhcPass 'Renamed) where+  collectXXPat _ ext = noExtCon ext +instance CollectPass (GhcPass 'Typechecked) where+  collectXXPat _ (CoPat _ pat _) = collect_pat pat++ {- Note [Dictionary binders in ConPatOut] See also same Note in GHC.HsToCore.Arrows ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -1144,7 +1216,6 @@                           hs_fords = foreign_decls })   =  collectHsValBinders val_decls   ++ hsTyClForeignBinders tycl_decls foreign_decls-hsGroupBinders (XHsGroup nec) = noExtCon nec  hsTyClForeignBinders :: [TyClGroup GhcRn]                      -> [LForeignDecl GhcRn]@@ -1176,8 +1247,6 @@ hsLTyClDeclBinders (L loc (FamDecl { tcdFam = FamilyDecl                                             { fdLName = (L _ name) } }))   = ([L loc name], [])-hsLTyClDeclBinders (L _ (FamDecl { tcdFam = XFamilyDecl nec }))-  = noExtCon nec hsLTyClDeclBinders (L loc (SynDecl                                { tcdLName = (L _ name) }))   = ([L loc name], [])@@ -1195,7 +1264,6 @@ hsLTyClDeclBinders (L loc (DataDecl    { tcdLName = (L _ name)                                        , tcdDataDefn = defn }))   = (\ (xs, ys) -> (L loc name : xs, ys)) $ hsDataDefnBinders defn-hsLTyClDeclBinders (L _ (XTyClDecl nec)) = noExtCon nec   -------------------@@ -1236,10 +1304,6 @@ hsLInstDeclBinders (L _ (DataFamInstD { dfid_inst = fi }))   = hsDataFamInstBinders fi hsLInstDeclBinders (L _ (TyFamInstD {})) = mempty-hsLInstDeclBinders (L _ (ClsInstD _ (XClsInstDecl nec)))-  = noExtCon nec-hsLInstDeclBinders (L _ (XInstDecl nec))-  = noExtCon nec  ------------------- -- | the 'SrcLoc' returned are for the whole declarations, not just the names@@ -1249,11 +1313,6 @@                        FamEqn { feqn_rhs = defn }}})   = hsDataDefnBinders defn   -- There can't be repeated symbols because only data instances have binders-hsDataFamInstBinders (DataFamInstDecl-                                    { dfid_eqn = HsIB { hsib_body = XFamEqn nec}})-  = noExtCon nec-hsDataFamInstBinders (DataFamInstDecl (XHsImplicitBndrs nec))-  = noExtCon nec  ------------------- -- | the 'SrcLoc' returned are for the whole declarations, not just the names@@ -1262,7 +1321,6 @@ hsDataDefnBinders (HsDataDefn { dd_cons = cons })   = hsConDeclsBinders cons   -- See Note [Binders in family instances]-hsDataDefnBinders (XHsDataDefn nec) = noExtCon nec  ------------------- type Seen p = [LFieldOcc (GhcPass p)] -> [LFieldOcc (GhcPass p)]@@ -1298,8 +1356,6 @@                 (remSeen', flds) = get_flds remSeen args                 (ns, fs) = go remSeen' rs -           XConDecl nec -> noExtCon nec-     get_flds :: Seen p -> HsConDeclDetails (GhcPass p)              -> (Seen p, [LFieldOcc (GhcPass p)])     get_flds remSeen (RecCon flds)@@ -1363,11 +1419,10 @@      hs_stmt :: StmtLR GhcRn (GhcPass idR) (Located (body (GhcPass idR)))             -> [(SrcSpan, [Name])]-    hs_stmt (BindStmt _ pat _ _ _) = lPatImplicits pat+    hs_stmt (BindStmt _ pat _) = lPatImplicits pat     hs_stmt (ApplicativeStmt _ args _) = concatMap do_arg args       where do_arg (_, ApplicativeArgOne { app_arg_pattern = pat }) = lPatImplicits pat             do_arg (_, ApplicativeArgMany { app_stmts = stmts }) = hs_lstmts stmts-            do_arg (_, XApplicativeArg nec) = noExtCon nec     hs_stmt (LetStmt _ binds)     = hs_local_binds (unLoc binds)     hs_stmt (BodyStmt {})         = []     hs_stmt (LastStmt {})         = []@@ -1375,12 +1430,10 @@                                                 , s <- ss]     hs_stmt (TransStmt { trS_stmts = stmts }) = hs_lstmts stmts     hs_stmt (RecStmt { recS_stmts = ss })     = hs_lstmts ss-    hs_stmt (XStmtLR nec)         = noExtCon nec      hs_local_binds (HsValBinds _ val_binds) = hsValBindsImplicits val_binds     hs_local_binds (HsIPBinds {})           = []     hs_local_binds (EmptyLocalBinds _)      = []-    hs_local_binds (XHsLocalBindsLR _)      = []  hsValBindsImplicits :: HsValBindsLR GhcRn (GhcPass idR) -> [(SrcSpan, [Name])] hsValBindsImplicits (XValBindsLR (NValBinds binds _))@@ -1410,10 +1463,8 @@     hs_pat (TuplePat _ pats _)  = hs_lpats pats      hs_pat (SigPat _ pat _)     = hs_lpat pat-    hs_pat (CoPat _ _ pat _)    = hs_pat pat -    hs_pat (ConPatIn n ps)           = details n ps-    hs_pat (ConPatOut {pat_con=con, pat_args=ps}) = details (fmap conLikeName con) ps+    hs_pat (ConPat {pat_con=con, pat_args=ps}) = details con ps      hs_pat _ = []
compiler/GHC/HsToCore/PmCheck/Types.hs view
@@ -8,7 +8,7 @@ {-# LANGUAGE TupleSections #-}  -- | Types used through-out pattern match checking. This module is mostly there--- to be imported from "TcRnTypes". The exposed API is that of+-- to be imported from "GHC.Tc.Types". The exposed API is that of -- "GHC.HsToCore.PmCheck.Oracle" and "GHC.HsToCore.PmCheck". module GHC.HsToCore.PmCheck.Types (         -- * Representations for Literals and AltCons@@ -39,11 +39,11 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import Util-import Bag-import FastString+import GHC.Utils.Misc+import GHC.Data.Bag+import GHC.Data.FastString import GHC.Types.Var (EvVar) import GHC.Types.Id import GHC.Types.Var.Env@@ -52,19 +52,19 @@ import GHC.Types.Name import GHC.Core.DataCon import GHC.Core.ConLike-import Outputable-import ListSetOps (unionLists)-import Maybes+import GHC.Utils.Outputable+import GHC.Data.List.SetOps (unionLists)+import GHC.Data.Maybe import GHC.Core.Type import GHC.Core.TyCon import GHC.Types.Literal import GHC.Core import GHC.Core.Map import GHC.Core.Utils (exprType)-import PrelNames-import TysWiredIn-import TysPrim-import TcType (evVarPred)+import GHC.Builtin.Names+import GHC.Builtin.Types+import GHC.Builtin.Types.Prim+import GHC.Tc.Utils.TcType (evVarPred)  import Numeric (fromRat) import Data.Foldable (find)@@ -545,7 +545,7 @@ initTmState :: TmState initTmState = TmSt emptySDIE emptyCoreMap --- | The type oracle state. A poor man's 'TcSMonad.InsertSet': The invariant is+-- | The type oracle state. A poor man's 'GHC.Tc.Solver.Monad.InsertSet': The invariant is -- that all constraints in there are mutually compatible. newtype TyState = TySt (Bag EvVar)
compiler/GHC/HsToCore/PmCheck/Types.hs-boot view
@@ -1,6 +1,6 @@ module GHC.HsToCore.PmCheck.Types where -import Bag+import GHC.Data.Bag  data Delta
+ compiler/GHC/Iface/Recomp/Binary.hs view
@@ -0,0 +1,49 @@+{-# LANGUAGE CPP #-}++-- | Computing fingerprints of values serializeable with GHC's "Binary" module.+module GHC.Iface.Recomp.Binary+  ( -- * Computing fingerprints+    fingerprintBinMem+  , computeFingerprint+  , putNameLiterally+  ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Utils.Fingerprint+import GHC.Utils.Binary+import GHC.Types.Name+import GHC.Utils.Panic.Plain+import GHC.Utils.Misc++fingerprintBinMem :: BinHandle -> IO Fingerprint+fingerprintBinMem bh = withBinBuffer bh f+  where+    f bs =+        -- we need to take care that we force the result here+        -- lest a reference to the ByteString may leak out of+        -- withBinBuffer.+        let fp = fingerprintByteString bs+        in fp `seq` return fp++computeFingerprint :: (Binary a)+                   => (BinHandle -> Name -> IO ())+                   -> a+                   -> IO Fingerprint+computeFingerprint put_nonbinding_name a = do+    bh <- fmap set_user_data $ openBinMem (3*1024) -- just less than a block+    put_ bh a+    fp <- fingerprintBinMem bh+    return fp+  where+    set_user_data bh =+      setUserData bh $ newWriteState put_nonbinding_name putNameLiterally putFS++-- | Used when we want to fingerprint a structure without depending on the+-- fingerprints of external Names that it refers to.+putNameLiterally :: BinHandle -> Name -> IO ()+putNameLiterally bh name = ASSERT( isExternalName name ) do+    put_ bh $! nameModule name+    put_ bh $! nameOccName name
compiler/GHC/Iface/Syntax.hs view
@@ -42,10 +42,10 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Iface.Type-import BinFingerprint+import GHC.Iface.Recomp.Binary import GHC.Core( IsOrphan, isOrphan ) import GHC.Types.Demand import GHC.Types.Cpr@@ -59,19 +59,19 @@ import GHC.Types.ForeignCall import GHC.Types.Annotations( AnnPayload, AnnTarget ) import GHC.Types.Basic-import Outputable-import GHC.Types.Module+import GHC.Utils.Outputable as Outputable+import GHC.Unit.Module import GHC.Types.SrcLoc-import Fingerprint-import Binary-import BooleanFormula ( BooleanFormula, pprBooleanFormula, isTrue )+import GHC.Utils.Fingerprint+import GHC.Utils.Binary+import GHC.Data.BooleanFormula ( BooleanFormula, pprBooleanFormula, isTrue ) import GHC.Types.Var( VarBndr(..), binderVar ) import GHC.Core.TyCon ( Role (..), Injectivity(..), tyConBndrVisArgFlag )-import Util( dropList, filterByList, notNull, unzipWith, debugIsOn )+import GHC.Utils.Misc( dropList, filterByList, notNull, unzipWith, debugIsOn ) import GHC.Core.DataCon (SrcStrictness(..), SrcUnpackedness(..)) import GHC.Utils.Lexeme (isLexSym)-import TysWiredIn ( constraintKindTyConName )-import Util (seqList)+import GHC.Builtin.Types ( constraintKindTyConName )+import GHC.Utils.Misc (seqList)  import Control.Monad import System.IO.Unsafe@@ -547,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 GHC.Core.Op.Tidy.tidyLetBndr, since+In general we retain all info that is left by GHC.Core.Tidy.tidyLetBndr, since that is what is seen by importing module with --make  Note [Displaying axiom incompatibilities]@@ -777,7 +777,7 @@                               then isIfaceTauType kind                                       -- Even in the presence of a standalone kind signature, a non-tau                                       -- result kind annotation cannot be discarded as it determines the arity.-                                      -- See Note [Arity inference in kcCheckDeclHeader_sig] in TcHsType+                                      -- See Note [Arity inference in kcCheckDeclHeader_sig] in GHC.Tc.Gen.HsType                               else isIfaceLiftedTypeKind kind)                           (dcolon <+> ppr kind)
compiler/GHC/Iface/Type.hs view
@@ -60,23 +60,24 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import {-# SOURCE #-} TysWiredIn ( coercibleTyCon, heqTyCon+import {-# SOURCE #-} GHC.Builtin.Types+                                 ( coercibleTyCon, heqTyCon                                  , liftedRepDataConTyCon, tupleTyConName ) import {-# SOURCE #-} GHC.Core.Type ( isRuntimeRepTy )  import GHC.Core.TyCon hiding ( pprPromotionQuote ) import GHC.Core.Coercion.Axiom import GHC.Types.Var-import PrelNames+import GHC.Builtin.Names import GHC.Types.Name import GHC.Types.Basic-import Binary-import Outputable-import FastString-import FastStringEnv-import Util+import GHC.Utils.Binary+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Data.FastString.Env+import GHC.Utils.Misc  import Data.Maybe( isJust ) import qualified Data.Semigroup as Semi@@ -267,7 +268,7 @@ Note [Equality predicates in IfaceType] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GHC has several varieties of type equality (see Note [The equality types story]-in TysPrim for details).  In an effort to avoid confusing users, we suppress+in GHC.Builtin.Types.Prim for details).  In an effort to avoid confusing users, we suppress the differences during pretty printing unless certain flags are enabled. Here is how each equality predicate* is printed in homogeneous and heterogeneous contexts, depending on which combination of the@@ -318,7 +319,7 @@ record whether this particular application is homogeneous in IfaceTyConSort for the purposes of pretty-printing. -See Note [The equality types story] in TysPrim.+See Note [The equality types story] in GHC.Builtin.Types.Prim. -}  data IfaceTyConInfo   -- Used to guide pretty-printing@@ -343,7 +344,7 @@   | IfaceAxiomRuleCo  IfLclName [IfaceCoercion]        -- There are only a fixed number of CoAxiomRules, so it suffices        -- to use an IfaceLclName to distinguish them.-       -- See Note [Adding built-in type families] in TcTypeNats+       -- See Note [Adding built-in type families] in GHC.Builtin.Types.Literals   | IfaceUnivCo       IfaceUnivCoProv Role IfaceType IfaceType   | IfaceSymCo        IfaceCoercion   | IfaceTransCo      IfaceCoercion IfaceCoercion@@ -1345,7 +1346,7 @@ --      heqTyCon         (~~) -- -- See Note [Equality predicates in IfaceType]--- and Note [The equality types story] in TysPrim+-- and Note [The equality types story] in GHC.Builtin.Types.Prim ppr_equality :: PprPrec -> IfaceTyCon -> [IfaceType] -> Maybe SDoc ppr_equality ctxt_prec tc args   | hetero_eq_tc
+ compiler/GHC/Parser/Annotation.hs view
@@ -0,0 +1,378 @@+{-# LANGUAGE DeriveDataTypeable #-}++module GHC.Parser.Annotation (+  getAnnotation, getAndRemoveAnnotation,+  getAnnotationComments,getAndRemoveAnnotationComments,+  ApiAnns(..),+  ApiAnnKey,+  AnnKeywordId(..),+  AnnotationComment(..),+  IsUnicodeSyntax(..),+  unicodeAnn,+  HasE(..),+  LRdrName -- Exists for haddocks only+  ) where++import GHC.Prelude++import GHC.Types.Name.Reader+import GHC.Utils.Outputable+import GHC.Types.SrcLoc+import qualified Data.Map as Map+import Data.Data+++{-+Note [Api annotations]+~~~~~~~~~~~~~~~~~~~~~~+Given a parse tree of a Haskell module, how can we reconstruct+the original Haskell source code, retaining all whitespace and+source code comments?  We need to track the locations of all+elements from the original source: this includes keywords such as+'let' / 'in' / 'do' etc as well as punctuation such as commas and+braces, and also comments.  We collectively refer to this+metadata as the "API annotations".++Rather than annotate the resulting parse tree with these locations+directly (this would be a major change to some fairly core data+structures in GHC), we instead capture locations for these elements in a+structure separate from the parse tree, and returned in the+pm_annotations field of the ParsedModule type.++The full ApiAnns type is++> data ApiAnns =+>  ApiAnns+>    { apiAnnItems :: Map.Map ApiAnnKey [RealSrcSpan],+>      apiAnnEofPos :: Maybe RealSrcSpan,+>      apiAnnComments :: Map.Map RealSrcSpan [RealLocated AnnotationComment],+>      apiAnnRogueComments :: [RealLocated AnnotationComment]+>    }++NON-COMMENT ELEMENTS++Intuitively, every AST element directly contains a bag of keywords+(keywords can show up more than once in a node: a semicolon i.e. newline+can show up multiple times before the next AST element), each of which+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 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 = (RealSrcSpan,AnnKeywordId)+>+> Map.Map ApiAnnKey [RealSrcSpan]++So++> let x = 1 in 2 *x++would result in the AST element++  L span (HsLet (binds for x = 1) (2 * x))++and the annotations++  (span,AnnLet) having the location of the 'let' keyword+  (span,AnnEqual) having the location of the '=' sign+  (span,AnnIn)  having the location of the 'in' keyword++For any given element in the AST, there is only a set number of+keywords that are applicable for it (e.g., you'll never see an+'import' keyword associated with a let-binding.)  The set of allowed+keywords is documented in a comment associated with the constructor+of a given AST element, although the ground truth is in GHC.Parser+and GHC.Parser.PostProcess (which actually add the annotations; see #13012).++COMMENT ELEMENTS++Every comment is associated with a *located* AnnotationComment.+We associate comments with the lowest (most specific) AST element+enclosing them:++> Map.Map RealSrcSpan [RealLocated AnnotationComment]++PARSER STATE++There are three fields in PState (the parser state) which play a role+with annotations.++>  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+(after they are passed to Map.fromList).++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 RealSrcSpan in+annotations_comments).++PARSER EMISSION OF ANNOTATIONS++The parser interacts with the lexer using the function++> addAnnotation :: RealSrcSpan -> AnnKeywordId -> RealSrcSpan -> P ()++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 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'.)++The wiki page describing this feature is+https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations++-}+-- ---------------------------------------------------------------------++-- If you update this, update the Note [Api annotations] above+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 = (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 -> 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 -> 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 -> 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 -> 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++-- --------------------------------------------------------------------++-- | API Annotations exist so that tools can perform source to source+-- conversions of Haskell code. They are used to keep track of the+-- various syntactic keywords that are not captured in the existing+-- AST.+--+-- The annotations, together with original source comments are made+-- available in the @'pm_annotations'@ field of @'GHC.ParsedModule'@.+-- Comments are only retained if @'Opt_KeepRawTokenStream'@ is set in+-- @'DynFlags.DynFlags'@ before parsing.+--+-- The wiki page describing this feature is+-- https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations+--+-- Note: in general the names of these are taken from the+-- corresponding token, unless otherwise noted+-- See note [Api annotations] above for details of the usage+data AnnKeywordId+    = AnnAnyclass+    | AnnAs+    | AnnAt+    | AnnBang  -- ^ '!'+    | AnnBackquote -- ^ '`'+    | AnnBy+    | AnnCase -- ^ case or lambda case+    | AnnClass+    | AnnClose -- ^  '\#)' or '\#-}'  etc+    | AnnCloseB -- ^ '|)'+    | AnnCloseBU -- ^ '|)', unicode variant+    | AnnCloseC -- ^ '}'+    | AnnCloseQ  -- ^ '|]'+    | AnnCloseQU -- ^ '|]', unicode variant+    | AnnCloseP -- ^ ')'+    | AnnCloseS -- ^ ']'+    | AnnColon+    | AnnComma -- ^ as a list separator+    | AnnCommaTuple -- ^ in a RdrName for a tuple+    | AnnDarrow -- ^ '=>'+    | AnnDarrowU -- ^ '=>', unicode variant+    | AnnData+    | AnnDcolon -- ^ '::'+    | AnnDcolonU -- ^ '::', unicode variant+    | AnnDefault+    | AnnDeriving+    | AnnDo+    | AnnDot    -- ^ '.'+    | AnnDotdot -- ^ '..'+    | AnnElse+    | AnnEqual+    | AnnExport+    | AnnFamily+    | AnnForall+    | AnnForallU -- ^ Unicode variant+    | AnnForeign+    | AnnFunId -- ^ for function name in matches where there are+               -- multiple equations for the function.+    | AnnGroup+    | AnnHeader -- ^ for CType+    | AnnHiding+    | AnnIf+    | AnnImport+    | AnnIn+    | AnnInfix -- ^ 'infix' or 'infixl' or 'infixr'+    | AnnInstance+    | AnnLam+    | AnnLarrow     -- ^ '<-'+    | AnnLarrowU    -- ^ '<-', unicode variant+    | AnnLet+    | AnnMdo+    | AnnMinus -- ^ '-'+    | AnnModule+    | AnnNewtype+    | AnnName -- ^ where a name loses its location in the AST, this carries it+    | AnnOf+    | AnnOpen    -- ^ '(\#' or '{-\# LANGUAGE' etc+    | AnnOpenB   -- ^ '(|'+    | AnnOpenBU  -- ^ '(|', unicode variant+    | AnnOpenC   -- ^ '{'+    | AnnOpenE   -- ^ '[e|' or '[e||'+    | AnnOpenEQ  -- ^ '[|'+    | AnnOpenEQU -- ^ '[|', unicode variant+    | AnnOpenP   -- ^ '('+    | AnnOpenS   -- ^ '['+    | AnnDollar          -- ^ prefix '$'   -- TemplateHaskell+    | AnnDollarDollar    -- ^ prefix '$$'  -- TemplateHaskell+    | AnnPackageName+    | AnnPattern+    | AnnProc+    | AnnQualified+    | AnnRarrow -- ^ '->'+    | AnnRarrowU -- ^ '->', unicode variant+    | AnnRec+    | AnnRole+    | AnnSafe+    | AnnSemi -- ^ ';'+    | AnnSimpleQuote -- ^ '''+    | AnnSignature+    | AnnStatic -- ^ 'static'+    | AnnStock+    | AnnThen+    | AnnThIdSplice -- ^ '$'+    | AnnThIdTySplice -- ^ '$$'+    | AnnThTyQuote -- ^ double '''+    | AnnTilde -- ^ '~'+    | AnnType+    | AnnUnit -- ^ '()' for types+    | AnnUsing+    | AnnVal  -- ^ e.g. INTEGER+    | AnnValStr  -- ^ String value, will need quotes when output+    | AnnVbar -- ^ '|'+    | AnnVia -- ^ 'via'+    | AnnWhere+    | Annlarrowtail -- ^ '-<'+    | AnnlarrowtailU -- ^ '-<', unicode variant+    | Annrarrowtail -- ^ '->'+    | AnnrarrowtailU -- ^ '->', unicode variant+    | AnnLarrowtail -- ^ '-<<'+    | AnnLarrowtailU -- ^ '-<<', unicode variant+    | AnnRarrowtail -- ^ '>>-'+    | AnnRarrowtailU -- ^ '>>-', unicode variant+    deriving (Eq, Ord, Data, Show)++instance Outputable AnnKeywordId where+  ppr x = text (show x)++-- ---------------------------------------------------------------------++data AnnotationComment =+  -- Documentation annotations+    AnnDocCommentNext  String     -- ^ something beginning '-- |'+  | AnnDocCommentPrev  String     -- ^ something beginning '-- ^'+  | AnnDocCommentNamed String     -- ^ something beginning '-- $'+  | AnnDocSection      Int String -- ^ a section heading+  | AnnDocOptions      String     -- ^ doc options (prune, ignore-exports, etc)+  | AnnLineComment     String     -- ^ comment starting by "--"+  | AnnBlockComment    String     -- ^ comment in {- -}+    deriving (Eq, Ord, Data, Show)+-- Note: these are based on the Token versions, but the Token type is+-- defined in GHC.Parser.Lexer and bringing it in here would create a loop++instance Outputable AnnotationComment where+  ppr x = text (show x)++-- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',+--             'ApiAnnotation.AnnClose','ApiAnnotation.AnnComma',+--             'ApiAnnotation.AnnRarrow'+--             'ApiAnnotation.AnnTilde'+--   - May have 'ApiAnnotation.AnnComma' when in a list+type LRdrName = Located RdrName+++-- | Certain tokens can have alternate representations when unicode syntax is+-- enabled. This flag is attached to those tokens in the lexer so that the+-- original source representation can be reproduced in the corresponding+-- 'ApiAnnotation'+data IsUnicodeSyntax = UnicodeSyntax | NormalSyntax+    deriving (Eq, Ord, Data, Show)++-- | Convert a normal annotation into its unicode equivalent one+unicodeAnn :: AnnKeywordId -> AnnKeywordId+unicodeAnn AnnForall     = AnnForallU+unicodeAnn AnnDcolon     = AnnDcolonU+unicodeAnn AnnLarrow     = AnnLarrowU+unicodeAnn AnnRarrow     = AnnRarrowU+unicodeAnn AnnDarrow     = AnnDarrowU+unicodeAnn Annlarrowtail = AnnlarrowtailU+unicodeAnn Annrarrowtail = AnnrarrowtailU+unicodeAnn AnnLarrowtail = AnnLarrowtailU+unicodeAnn AnnRarrowtail = AnnRarrowtailU+unicodeAnn AnnOpenB      = AnnOpenBU+unicodeAnn AnnCloseB     = AnnCloseBU+unicodeAnn AnnOpenEQ     = AnnOpenEQU+unicodeAnn AnnCloseQ     = AnnCloseQU+unicodeAnn ann           = ann+++-- | Some template haskell tokens have two variants, one with an `e` the other+-- not:+--+-- >  [| or [e|+-- >  [|| or [e||+--+-- This type indicates whether the 'e' is present or not.+data HasE = HasE | NoE+     deriving (Eq, Ord, Data, Show)
+ compiler/GHC/Parser/CharClass.hs view
@@ -0,0 +1,215 @@+-- Character classification+{-# LANGUAGE CPP #-}+module GHC.Parser.CharClass+        ( is_ident      -- Char# -> Bool+        , is_symbol     -- Char# -> Bool+        , is_any        -- Char# -> Bool+        , is_space      -- Char# -> Bool+        , is_lower      -- Char# -> Bool+        , is_upper      -- Char# -> Bool+        , is_digit      -- Char# -> Bool+        , is_alphanum   -- Char# -> Bool++        , is_decdigit, is_hexdigit, is_octdigit, is_bindigit+        , hexDigit, octDecDigit+        ) where++#include "HsVersions.h"++import GHC.Prelude++import Data.Bits        ( Bits((.&.),(.|.)) )+import Data.Char        ( ord, chr )+import Data.Word+import GHC.Utils.Panic++-- Bit masks++cIdent, cSymbol, cAny, cSpace, cLower, cUpper, cDigit :: Word8+cIdent  =  1+cSymbol =  2+cAny    =  4+cSpace  =  8+cLower  = 16+cUpper  = 32+cDigit  = 64++-- | The predicates below look costly, but aren't, GHC+GCC do a great job+-- at the big case below.++{-# INLINABLE is_ctype #-}+is_ctype :: Word8 -> Char -> Bool+is_ctype mask c = (charType c .&. mask) /= 0++is_ident, is_symbol, is_any, is_space, is_lower, is_upper, is_digit,+    is_alphanum :: Char -> Bool+is_ident  = is_ctype cIdent+is_symbol = is_ctype cSymbol+is_any    = is_ctype cAny+is_space  = is_ctype cSpace+is_lower  = is_ctype cLower+is_upper  = is_ctype cUpper+is_digit  = is_ctype cDigit+is_alphanum = is_ctype (cLower+cUpper+cDigit)++-- Utils++hexDigit :: Char -> Int+hexDigit c | is_decdigit c = ord c - ord '0'+           | otherwise     = ord (to_lower c) - ord 'a' + 10++octDecDigit :: Char -> Int+octDecDigit c = ord c - ord '0'++is_decdigit :: Char -> Bool+is_decdigit c+        =  c >= '0' && c <= '9'++is_hexdigit :: Char -> Bool+is_hexdigit c+        =  is_decdigit c+        || (c >= 'a' && c <= 'f')+        || (c >= 'A' && c <= 'F')++is_octdigit :: Char -> Bool+is_octdigit c = c >= '0' && c <= '7'++is_bindigit :: Char -> Bool+is_bindigit c = c == '0' || c == '1'++to_lower :: Char -> Char+to_lower c+  | c >=  'A' && c <= 'Z' = chr (ord c - (ord 'A' - ord 'a'))+  | otherwise = c++charType :: Char -> Word8+charType c = case c of+   '\0'   -> 0                             -- \000+   '\1'   -> 0                             -- \001+   '\2'   -> 0                             -- \002+   '\3'   -> 0                             -- \003+   '\4'   -> 0                             -- \004+   '\5'   -> 0                             -- \005+   '\6'   -> 0                             -- \006+   '\7'   -> 0                             -- \007+   '\8'   -> 0                             -- \010+   '\9'   -> cSpace                        -- \t  (not allowed in strings, so !cAny)+   '\10'  -> cSpace                        -- \n  (ditto)+   '\11'  -> cSpace                        -- \v  (ditto)+   '\12'  -> cSpace                        -- \f  (ditto)+   '\13'  -> cSpace                        --  ^M (ditto)+   '\14'  -> 0                             -- \016+   '\15'  -> 0                             -- \017+   '\16'  -> 0                             -- \020+   '\17'  -> 0                             -- \021+   '\18'  -> 0                             -- \022+   '\19'  -> 0                             -- \023+   '\20'  -> 0                             -- \024+   '\21'  -> 0                             -- \025+   '\22'  -> 0                             -- \026+   '\23'  -> 0                             -- \027+   '\24'  -> 0                             -- \030+   '\25'  -> 0                             -- \031+   '\26'  -> 0                             -- \032+   '\27'  -> 0                             -- \033+   '\28'  -> 0                             -- \034+   '\29'  -> 0                             -- \035+   '\30'  -> 0                             -- \036+   '\31'  -> 0                             -- \037+   '\32'  -> cAny .|. cSpace               --+   '\33'  -> cAny .|. cSymbol              -- !+   '\34'  -> cAny                          -- "+   '\35'  -> cAny .|. cSymbol              --  #+   '\36'  -> cAny .|. cSymbol              --  $+   '\37'  -> cAny .|. cSymbol              -- %+   '\38'  -> cAny .|. cSymbol              -- &+   '\39'  -> cAny .|. cIdent               -- '+   '\40'  -> cAny                          -- (+   '\41'  -> cAny                          -- )+   '\42'  -> cAny .|. cSymbol              --  *+   '\43'  -> cAny .|. cSymbol              -- ++   '\44'  -> cAny                          -- ,+   '\45'  -> cAny .|. cSymbol              -- -+   '\46'  -> cAny .|. cSymbol              -- .+   '\47'  -> cAny .|. cSymbol              --  /+   '\48'  -> cAny .|. cIdent  .|. cDigit   -- 0+   '\49'  -> cAny .|. cIdent  .|. cDigit   -- 1+   '\50'  -> cAny .|. cIdent  .|. cDigit   -- 2+   '\51'  -> cAny .|. cIdent  .|. cDigit   -- 3+   '\52'  -> cAny .|. cIdent  .|. cDigit   -- 4+   '\53'  -> cAny .|. cIdent  .|. cDigit   -- 5+   '\54'  -> cAny .|. cIdent  .|. cDigit   -- 6+   '\55'  -> cAny .|. cIdent  .|. cDigit   -- 7+   '\56'  -> cAny .|. cIdent  .|. cDigit   -- 8+   '\57'  -> cAny .|. cIdent  .|. cDigit   -- 9+   '\58'  -> cAny .|. cSymbol              -- :+   '\59'  -> cAny                          -- ;+   '\60'  -> cAny .|. cSymbol              -- <+   '\61'  -> cAny .|. cSymbol              -- =+   '\62'  -> cAny .|. cSymbol              -- >+   '\63'  -> cAny .|. cSymbol              -- ?+   '\64'  -> cAny .|. cSymbol              -- @+   '\65'  -> cAny .|. cIdent  .|. cUpper   -- A+   '\66'  -> cAny .|. cIdent  .|. cUpper   -- B+   '\67'  -> cAny .|. cIdent  .|. cUpper   -- C+   '\68'  -> cAny .|. cIdent  .|. cUpper   -- D+   '\69'  -> cAny .|. cIdent  .|. cUpper   -- E+   '\70'  -> cAny .|. cIdent  .|. cUpper   -- F+   '\71'  -> cAny .|. cIdent  .|. cUpper   -- G+   '\72'  -> cAny .|. cIdent  .|. cUpper   -- H+   '\73'  -> cAny .|. cIdent  .|. cUpper   -- I+   '\74'  -> cAny .|. cIdent  .|. cUpper   -- J+   '\75'  -> cAny .|. cIdent  .|. cUpper   -- K+   '\76'  -> cAny .|. cIdent  .|. cUpper   -- L+   '\77'  -> cAny .|. cIdent  .|. cUpper   -- M+   '\78'  -> cAny .|. cIdent  .|. cUpper   -- N+   '\79'  -> cAny .|. cIdent  .|. cUpper   -- O+   '\80'  -> cAny .|. cIdent  .|. cUpper   -- P+   '\81'  -> cAny .|. cIdent  .|. cUpper   -- Q+   '\82'  -> cAny .|. cIdent  .|. cUpper   -- R+   '\83'  -> cAny .|. cIdent  .|. cUpper   -- S+   '\84'  -> cAny .|. cIdent  .|. cUpper   -- T+   '\85'  -> cAny .|. cIdent  .|. cUpper   -- U+   '\86'  -> cAny .|. cIdent  .|. cUpper   -- V+   '\87'  -> cAny .|. cIdent  .|. cUpper   -- W+   '\88'  -> cAny .|. cIdent  .|. cUpper   -- X+   '\89'  -> cAny .|. cIdent  .|. cUpper   -- Y+   '\90'  -> cAny .|. cIdent  .|. cUpper   -- Z+   '\91'  -> cAny                          -- [+   '\92'  -> cAny .|. cSymbol              -- backslash+   '\93'  -> cAny                          -- ]+   '\94'  -> cAny .|. cSymbol              --  ^+   '\95'  -> cAny .|. cIdent  .|. cLower   -- _+   '\96'  -> cAny                          -- `+   '\97'  -> cAny .|. cIdent  .|. cLower   -- a+   '\98'  -> cAny .|. cIdent  .|. cLower   -- b+   '\99'  -> cAny .|. cIdent  .|. cLower   -- c+   '\100' -> cAny .|. cIdent  .|. cLower   -- d+   '\101' -> cAny .|. cIdent  .|. cLower   -- e+   '\102' -> cAny .|. cIdent  .|. cLower   -- f+   '\103' -> cAny .|. cIdent  .|. cLower   -- g+   '\104' -> cAny .|. cIdent  .|. cLower   -- h+   '\105' -> cAny .|. cIdent  .|. cLower   -- i+   '\106' -> cAny .|. cIdent  .|. cLower   -- j+   '\107' -> cAny .|. cIdent  .|. cLower   -- k+   '\108' -> cAny .|. cIdent  .|. cLower   -- l+   '\109' -> cAny .|. cIdent  .|. cLower   -- m+   '\110' -> cAny .|. cIdent  .|. cLower   -- n+   '\111' -> cAny .|. cIdent  .|. cLower   -- o+   '\112' -> cAny .|. cIdent  .|. cLower   -- p+   '\113' -> cAny .|. cIdent  .|. cLower   -- q+   '\114' -> cAny .|. cIdent  .|. cLower   -- r+   '\115' -> cAny .|. cIdent  .|. cLower   -- s+   '\116' -> cAny .|. cIdent  .|. cLower   -- t+   '\117' -> cAny .|. cIdent  .|. cLower   -- u+   '\118' -> cAny .|. cIdent  .|. cLower   -- v+   '\119' -> cAny .|. cIdent  .|. cLower   -- w+   '\120' -> cAny .|. cIdent  .|. cLower   -- x+   '\121' -> cAny .|. cIdent  .|. cLower   -- y+   '\122' -> cAny .|. cIdent  .|. cLower   -- z+   '\123' -> cAny                          -- {+   '\124' -> cAny .|. cSymbol              --  |+   '\125' -> cAny                          -- }+   '\126' -> cAny .|. cSymbol              -- ~+   '\127' -> 0                             -- \177+   _ -> panic ("charType: " ++ show c)
+ compiler/GHC/Parser/Header.hs view
@@ -0,0 +1,361 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE TypeFamilies #-}++-----------------------------------------------------------------------------+--+-- | Parsing the top of a Haskell source file to get its module name,+-- imports and options.+--+-- (c) Simon Marlow 2005+-- (c) Lemmih 2006+--+-----------------------------------------------------------------------------++module GHC.Parser.Header+   ( getImports+   , mkPrelImports -- used by the renamer too+   , getOptionsFromFile+   , getOptions+   , optionsErrorMsgs+   , checkProcessArgsResult+   )+where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Platform+import GHC.Driver.Types+import GHC.Parser           ( parseHeader )+import GHC.Parser.Lexer+import GHC.Data.FastString+import GHC.Hs+import GHC.Unit.Module+import GHC.Builtin.Names+import GHC.Data.StringBuffer+import GHC.Types.SrcLoc+import GHC.Driver.Session+import GHC.Utils.Error+import GHC.Utils.Misc+import GHC.Utils.Outputable as Outputable+import GHC.Data.Maybe+import GHC.Data.Bag         ( emptyBag, listToBag, unitBag )+import GHC.Utils.Monad+import GHC.Utils.Exception as Exception+import GHC.Types.Basic+import qualified GHC.LanguageExtensions as LangExt++import Control.Monad+import System.IO+import System.IO.Unsafe+import Data.List++------------------------------------------------------------------------------++-- | Parse the imports of a source file.+--+-- Throws a 'SourceError' if parsing fails.+getImports :: DynFlags+           -> StringBuffer -- ^ Parse this.+           -> FilePath     -- ^ Filename the buffer came from.  Used for+                           --   reporting parse error locations.+           -> FilePath     -- ^ The original source filename (used for locations+                           --   in the function result)+           -> IO (Either+               ErrorMessages+               ([(Maybe FastString, Located ModuleName)],+                [(Maybe FastString, Located ModuleName)],+                Located ModuleName))+              -- ^ The source imports and normal imports (with optional package+              -- names from -XPackageImports), and the module name.+getImports dflags buf filename source_filename = do+  let loc  = mkRealSrcLoc (mkFastString filename) 1 1+  case unP parseHeader (mkPState dflags buf loc) of+    PFailed pst ->+        -- assuming we're not logging warnings here as per below+      return $ Left $ getErrorMessages pst dflags+    POk pst rdr_module -> fmap Right $ do+      let _ms@(_warns, errs) = getMessages pst dflags+      -- don't log warnings: they'll be reported when we parse the file+      -- for real.  See #2500.+          ms = (emptyBag, errs)+      -- logWarnings warns+      if errorsFound dflags ms+        then throwIO $ mkSrcErr errs+        else+          let   hsmod = unLoc rdr_module+                mb_mod = hsmodName hsmod+                imps = hsmodImports hsmod+                main_loc = srcLocSpan (mkSrcLoc (mkFastString source_filename)+                                       1 1)+                mod = mb_mod `orElse` L main_loc mAIN_NAME+                (src_idecls, ord_idecls) = partition (ideclSource.unLoc) imps++               -- GHC.Prim doesn't exist physically, so don't go looking for it.+                ordinary_imps = filter ((/= moduleName gHC_PRIM) . unLoc+                                        . ideclName . unLoc)+                                       ord_idecls++                implicit_prelude = xopt LangExt.ImplicitPrelude dflags+                implicit_imports = mkPrelImports (unLoc mod) main_loc+                                                 implicit_prelude imps+                convImport (L _ i) = (fmap sl_fs (ideclPkgQual i), ideclName i)+              in+              return (map convImport src_idecls,+                      map convImport (implicit_imports ++ ordinary_imps),+                      mod)++mkPrelImports :: ModuleName+              -> SrcSpan    -- Attribute the "import Prelude" to this location+              -> Bool -> [LImportDecl GhcPs]+              -> [LImportDecl GhcPs]+-- Construct the implicit declaration "import Prelude" (or not)+--+-- NB: opt_NoImplicitPrelude is slightly different to import Prelude ();+-- because the former doesn't even look at Prelude.hi for instance+-- declarations, whereas the latter does.+mkPrelImports this_mod loc implicit_prelude import_decls+  | this_mod == pRELUDE_NAME+   || explicit_prelude_import+   || not implicit_prelude+  = []+  | otherwise = [preludeImportDecl]+  where+      explicit_prelude_import+       = notNull [ () | L _ (ImportDecl { ideclName = mod+                                        , ideclPkgQual = Nothing })+                          <- import_decls+                      , unLoc mod == pRELUDE_NAME ]++      preludeImportDecl :: LImportDecl GhcPs+      preludeImportDecl+        = L loc $ ImportDecl { ideclExt       = noExtField,+                               ideclSourceSrc = NoSourceText,+                               ideclName      = L loc pRELUDE_NAME,+                               ideclPkgQual   = Nothing,+                               ideclSource    = False,+                               ideclSafe      = False,  -- Not a safe import+                               ideclQualified = NotQualified,+                               ideclImplicit  = True,   -- Implicit!+                               ideclAs        = Nothing,+                               ideclHiding    = Nothing  }++--------------------------------------------------------------+-- Get options+--------------------------------------------------------------++-- | Parse OPTIONS and LANGUAGE pragmas of the source file.+--+-- Throws a 'SourceError' if flag parsing fails (including unsupported flags.)+getOptionsFromFile :: DynFlags+                   -> FilePath            -- ^ Input file+                   -> IO [Located String] -- ^ Parsed options, if any.+getOptionsFromFile dflags filename+    = Exception.bracket+              (openBinaryFile filename ReadMode)+              (hClose)+              (\handle -> do+                  opts <- fmap (getOptions' dflags)+                               (lazyGetToks dflags' filename handle)+                  seqList opts $ return opts)+    where -- We don't need to get haddock doc tokens when we're just+          -- getting the options from pragmas, and lazily lexing them+          -- correctly is a little tricky: If there is "\n" or "\n-"+          -- left at the end of a buffer then the haddock doc may+          -- continue past the end of the buffer, despite the fact that+          -- we already have an apparently-complete token.+          -- We therefore just turn Opt_Haddock off when doing the lazy+          -- lex.+          dflags' = gopt_unset dflags Opt_Haddock++blockSize :: Int+-- blockSize = 17 -- for testing :-)+blockSize = 1024++lazyGetToks :: DynFlags -> FilePath -> Handle -> IO [Located Token]+lazyGetToks dflags filename handle = do+  buf <- hGetStringBufferBlock handle blockSize+  unsafeInterleaveIO $ lazyLexBuf handle (pragState dflags buf loc) False blockSize+ where+  loc  = mkRealSrcLoc (mkFastString filename) 1 1++  lazyLexBuf :: Handle -> PState -> Bool -> Int -> IO [Located Token]+  lazyLexBuf handle state eof size = do+    case unP (lexer False return) state of+      POk state' t -> do+        -- pprTrace "lazyLexBuf" (text (show (buffer state'))) (return ())+        if atEnd (buffer state') && not eof+           -- if this token reached the end of the buffer, and we haven't+           -- necessarily read up to the end of the file, then the token might+           -- be truncated, so read some more of the file and lex it again.+           then getMore handle state size+           else case unLoc t of+                  ITeof  -> return [t]+                  _other -> do rest <- lazyLexBuf handle state' eof size+                               return (t : rest)+      _ | not eof   -> getMore handle state size+        | otherwise -> return [L (mkSrcSpanPs (last_loc state)) ITeof]+                         -- parser assumes an ITeof sentinel at the end++  getMore :: Handle -> PState -> Int -> IO [Located Token]+  getMore handle state size = do+     -- pprTrace "getMore" (text (show (buffer state))) (return ())+     let new_size = size * 2+       -- double the buffer size each time we read a new block.  This+       -- counteracts the quadratic slowdown we otherwise get for very+       -- large module names (#5981)+     nextbuf <- hGetStringBufferBlock handle new_size+     if (len nextbuf == 0) then lazyLexBuf handle state True new_size else do+       newbuf <- appendStringBuffers (buffer state) nextbuf+       unsafeInterleaveIO $ lazyLexBuf handle state{buffer=newbuf} False new_size+++getToks :: DynFlags -> FilePath -> StringBuffer -> [Located Token]+getToks dflags filename buf = lexAll (pragState dflags buf loc)+ where+  loc  = mkRealSrcLoc (mkFastString filename) 1 1++  lexAll state = case unP (lexer False return) state of+                   POk _      t@(L _ ITeof) -> [t]+                   POk state' t -> t : lexAll state'+                   _ -> [L (mkSrcSpanPs (last_loc state)) ITeof]+++-- | Parse OPTIONS and LANGUAGE pragmas of the source file.+--+-- Throws a 'SourceError' if flag parsing fails (including unsupported flags.)+getOptions :: DynFlags+           -> StringBuffer -- ^ Input Buffer+           -> FilePath     -- ^ Source filename.  Used for location info.+           -> [Located String] -- ^ Parsed options.+getOptions dflags buf filename+    = getOptions' dflags (getToks dflags filename buf)++-- The token parser is written manually because Happy can't+-- return a partial result when it encounters a lexer error.+-- We want to extract options before the buffer is passed through+-- CPP, so we can't use the same trick as 'getImports'.+getOptions' :: DynFlags+            -> [Located Token]      -- Input buffer+            -> [Located String]     -- Options.+getOptions' dflags toks+    = parseToks toks+    where+          parseToks (open:close:xs)+              | IToptions_prag str <- unLoc open+              , ITclose_prag       <- unLoc close+              = case toArgs str of+                  Left _err -> optionsParseError str dflags $   -- #15053+                                 combineSrcSpans (getLoc open) (getLoc close)+                  Right args -> map (L (getLoc open)) args ++ parseToks xs+          parseToks (open:close:xs)+              | ITinclude_prag str <- unLoc open+              , ITclose_prag       <- unLoc close+              = map (L (getLoc open)) ["-#include",removeSpaces str] +++                parseToks xs+          parseToks (open:close:xs)+              | ITdocOptions str <- unLoc open+              , ITclose_prag     <- unLoc close+              = map (L (getLoc open)) ["-haddock-opts", removeSpaces str]+                ++ parseToks xs+          parseToks (open:xs)+              | ITlanguage_prag <- unLoc open+              = parseLanguage xs+          parseToks (comment:xs) -- Skip over comments+              | isComment (unLoc comment)+              = parseToks xs+          parseToks _ = []+          parseLanguage ((L loc (ITconid fs)):rest)+              = checkExtension dflags (L loc fs) :+                case rest of+                  (L _loc ITcomma):more -> parseLanguage more+                  (L _loc ITclose_prag):more -> parseToks more+                  (L loc _):_ -> languagePragParseError dflags loc+                  [] -> panic "getOptions'.parseLanguage(1) went past eof token"+          parseLanguage (tok:_)+              = languagePragParseError dflags (getLoc tok)+          parseLanguage []+              = panic "getOptions'.parseLanguage(2) went past eof token"++          isComment :: Token -> Bool+          isComment c =+            case c of+              (ITlineComment {})     -> True+              (ITblockComment {})    -> True+              (ITdocCommentNext {})  -> True+              (ITdocCommentPrev {})  -> True+              (ITdocCommentNamed {}) -> True+              (ITdocSection {})      -> True+              _                      -> False++-----------------------------------------------------------------------------++-- | Complain about non-dynamic flags in OPTIONS pragmas.+--+-- Throws a 'SourceError' if the input list is non-empty claiming that the+-- input flags are unknown.+checkProcessArgsResult :: MonadIO m => DynFlags -> [Located String] -> m ()+checkProcessArgsResult dflags flags+  = when (notNull flags) $+      liftIO $ throwIO $ mkSrcErr $ listToBag $ map mkMsg flags+    where mkMsg (L loc flag)+              = mkPlainErrMsg dflags loc $+                  (text "unknown flag in  {-# OPTIONS_GHC #-} pragma:" <+>+                   text flag)++-----------------------------------------------------------------------------++checkExtension :: DynFlags -> Located FastString -> Located String+checkExtension dflags (L l ext)+-- Checks if a given extension is valid, and if so returns+-- its corresponding flag. Otherwise it throws an exception.+  = if ext' `elem` supported+    then L l ("-X"++ext')+    else unsupportedExtnError dflags l ext'+  where+    ext' = unpackFS ext+    supported = supportedLanguagesAndExtensions $ platformMini $ targetPlatform dflags++languagePragParseError :: DynFlags -> SrcSpan -> a+languagePragParseError dflags loc =+    throwErr dflags loc $+       vcat [ text "Cannot parse LANGUAGE pragma"+            , text "Expecting comma-separated list of language options,"+            , text "each starting with a capital letter"+            , nest 2 (text "E.g. {-# LANGUAGE TemplateHaskell, GADTs #-}") ]++unsupportedExtnError :: DynFlags -> SrcSpan -> String -> a+unsupportedExtnError dflags loc unsup =+    throwErr dflags loc $+        text "Unsupported extension: " <> text unsup $$+        if null suggestions then Outputable.empty else text "Perhaps you meant" <+> quotedListWithOr (map text suggestions)+  where+     supported = supportedLanguagesAndExtensions $ platformMini $ targetPlatform dflags+     suggestions = fuzzyMatch unsup supported+++optionsErrorMsgs :: DynFlags -> [String] -> [Located String] -> FilePath -> Messages+optionsErrorMsgs dflags unhandled_flags flags_lines _filename+  = (emptyBag, listToBag (map mkMsg unhandled_flags_lines))+  where unhandled_flags_lines :: [Located String]+        unhandled_flags_lines = [ L l f+                                | f <- unhandled_flags+                                , L l f' <- flags_lines+                                , f == f' ]+        mkMsg (L flagSpan flag) =+            GHC.Utils.Error.mkPlainErrMsg dflags flagSpan $+                    text "unknown flag in  {-# OPTIONS_GHC #-} pragma:" <+> text flag++optionsParseError :: String -> DynFlags -> SrcSpan -> a     -- #15053+optionsParseError str dflags loc =+  throwErr dflags loc $+      vcat [ text "Error while parsing OPTIONS_GHC pragma."+           , text "Expecting whitespace-separated list of GHC options."+           , text "  E.g. {-# OPTIONS_GHC -Wall -O2 #-}"+           , text ("Input was: " ++ show str) ]++throwErr :: DynFlags -> SrcSpan -> SDoc -> a                -- #15053+throwErr dflags loc doc =+  throw $ mkSrcErr $ unitBag $ mkPlainErrMsg dflags loc doc
+ compiler/GHC/Parser/PostProcess.hs view
@@ -0,0 +1,3107 @@+--+--  (c) The University of Glasgow 2002-2006+--++-- Functions over HsSyn specialised to RdrName.++{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++module GHC.Parser.PostProcess (+        mkHsOpApp,+        mkHsIntegral, mkHsFractional, mkHsIsString,+        mkHsDo, mkSpliceDecl,+        mkRoleAnnotDecl,+        mkClassDecl,+        mkTyData, mkDataFamInst,+        mkTySynonym, mkTyFamInstEqn,+        mkStandaloneKindSig,+        mkTyFamInst,+        mkFamDecl, mkLHsSigType,+        mkInlinePragma,+        mkPatSynMatchGroup,+        mkRecConstrOrUpdate, -- HsExp -> [HsFieldUpdate] -> P HsExp+        mkTyClD, mkInstD,+        mkRdrRecordCon, mkRdrRecordUpd,+        setRdrNameSpace,+        filterCTuple,++        cvBindGroup,+        cvBindsAndSigs,+        cvTopDecls,+        placeHolderPunRhs,++        -- Stuff to do with Foreign declarations+        mkImport,+        parseCImport,+        mkExport,+        mkExtName,    -- RdrName -> CLabelString+        mkGadtDecl,   -- [Located RdrName] -> LHsType RdrName -> ConDecl RdrName+        mkConDeclH98,++        -- Bunch of functions in the parser monad for+        -- checking and constructing values+        checkImportDecl,+        checkExpBlockArguments, checkCmdBlockArguments,+        checkPrecP,           -- Int -> P Int+        checkContext,         -- HsType -> P HsContext+        checkPattern,         -- HsExp -> P HsPat+        checkPattern_msg,+        checkMonadComp,       -- P (HsStmtContext GhcPs)+        checkValDef,          -- (SrcLoc, HsExp, HsRhs, [HsDecl]) -> P HsDecl+        checkValSigLhs,+        LRuleTyTmVar, RuleTyTmVar(..),+        mkRuleBndrs, mkRuleTyVarBndrs,+        checkRuleTyVarBndrNames,+        checkRecordSyntax,+        checkEmptyGADTs,+        addFatalError, hintBangPat,+        TyEl(..), mergeOps, mergeDataCon,+        mkBangTy,++        -- Help with processing exports+        ImpExpSubSpec(..),+        ImpExpQcSpec(..),+        mkModuleImpExp,+        mkTypeImpExp,+        mkImpExpSubSpec,+        checkImportSpec,++        -- Token symbols+        forallSym,+        starSym,++        -- Warnings and errors+        warnStarIsType,+        warnPrepositiveQualifiedModule,+        failOpFewArgs,+        failOpNotEnabledImportQualifiedPost,+        failOpImportQualifiedTwice,++        SumOrTuple (..),++        -- Expression/command/pattern ambiguity resolution+        PV,+        runPV,+        ECP(ECP, runECP_PV),+        runECP_P,+        DisambInfixOp(..),+        DisambECP(..),+        ecpFromExp,+        ecpFromCmd,+        PatBuilder+    ) where++import GHC.Prelude+import GHC.Hs           -- Lots of it+import GHC.Core.TyCon          ( TyCon, isTupleTyCon, tyConSingleDataCon_maybe )+import GHC.Core.DataCon        ( DataCon, dataConTyCon )+import GHC.Core.ConLike        ( ConLike(..) )+import GHC.Core.Coercion.Axiom ( Role, fsFromRole )+import GHC.Types.Name.Reader+import GHC.Types.Name+import GHC.Types.Basic+import GHC.Parser.Lexer+import GHC.Utils.Lexeme ( isLexCon )+import GHC.Core.Type    ( TyThing(..), funTyCon )+import GHC.Builtin.Types( cTupleTyConName, tupleTyCon, tupleDataCon,+                          nilDataConName, nilDataConKey,+                          listTyConName, listTyConKey, eqTyCon_RDR,+                          tupleTyConName, cTupleTyConNameArity_maybe )+import GHC.Types.ForeignCall+import GHC.Builtin.Names ( allNameStrings )+import GHC.Types.SrcLoc+import GHC.Types.Unique ( hasKey )+import GHC.Data.OrdList ( OrdList, fromOL )+import GHC.Data.Bag     ( emptyBag, consBag )+import GHC.Utils.Outputable as Outputable+import GHC.Data.FastString+import GHC.Data.Maybe+import GHC.Utils.Misc+import GHC.Parser.Annotation+import Data.List+import GHC.Driver.Session ( WarningFlag(..), DynFlags )+import GHC.Utils.Error ( Messages )++import Control.Monad+import Text.ParserCombinators.ReadP as ReadP+import Data.Char+import qualified Data.Monoid as Monoid+import Data.Data       ( dataTypeOf, fromConstr, dataTypeConstrs )+import Data.Kind       ( Type )++#include "HsVersions.h"+++{- **********************************************************************++  Construction functions for Rdr stuff++  ********************************************************************* -}++-- | mkClassDecl builds a RdrClassDecl, filling in the names for tycon and+-- datacon by deriving them from the name of the class.  We fill in the names+-- for the tycon and datacon corresponding to the class, by deriving them+-- from the name of the class itself.  This saves recording the names in the+-- interface file (which would be equally good).++-- Similarly for mkConDecl, mkClassOpSig and default-method names.++--         *** See Note [The Naming story] in GHC.Hs.Decls ****++mkTyClD :: LTyClDecl (GhcPass p) -> LHsDecl (GhcPass p)+mkTyClD (L loc d) = L loc (TyClD noExtField d)++mkInstD :: LInstDecl (GhcPass p) -> LHsDecl (GhcPass p)+mkInstD (L loc d) = L loc (InstD noExtField d)++mkClassDecl :: SrcSpan+            -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)+            -> Located (a,[LHsFunDep GhcPs])+            -> OrdList (LHsDecl GhcPs)+            -> P (LTyClDecl GhcPs)++mkClassDecl loc (L _ (mcxt, tycl_hdr)) fds where_cls+  = do { (binds, sigs, ats, at_defs, _, docs) <- cvBindsAndSigs where_cls+       ; let cxt = fromMaybe (noLoc []) mcxt+       ; (cls, tparams, fixity, ann) <- checkTyClHdr True tycl_hdr+       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan+       ; (tyvars,annst) <- checkTyVars (text "class") whereDots cls tparams+       ; addAnnsAt loc annst -- Add any API Annotations to the top SrcSpan+       ; return (L loc (ClassDecl { tcdCExt = noExtField, tcdCtxt = cxt+                                  , tcdLName = cls, tcdTyVars = tyvars+                                  , tcdFixity = fixity+                                  , tcdFDs = snd (unLoc fds)+                                  , tcdSigs = mkClassOpSigs sigs+                                  , tcdMeths = binds+                                  , tcdATs = ats, tcdATDefs = at_defs+                                  , tcdDocs  = docs })) }++mkTyData :: SrcSpan+         -> NewOrData+         -> Maybe (Located CType)+         -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)+         -> Maybe (LHsKind GhcPs)+         -> [LConDecl GhcPs]+         -> HsDeriving GhcPs+         -> P (LTyClDecl GhcPs)+mkTyData loc new_or_data cType (L _ (mcxt, tycl_hdr))+         ksig data_cons maybe_deriv+  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False tycl_hdr+       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan+       ; (tyvars, anns) <- checkTyVars (ppr new_or_data) equalsDots tc tparams+       ; addAnnsAt loc anns -- Add any API Annotations to the top SrcSpan+       ; defn <- mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv+       ; return (L loc (DataDecl { tcdDExt = noExtField,+                                   tcdLName = tc, tcdTyVars = tyvars,+                                   tcdFixity = fixity,+                                   tcdDataDefn = defn })) }++mkDataDefn :: NewOrData+           -> Maybe (Located CType)+           -> Maybe (LHsContext GhcPs)+           -> Maybe (LHsKind GhcPs)+           -> [LConDecl GhcPs]+           -> HsDeriving GhcPs+           -> P (HsDataDefn GhcPs)+mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv+  = do { checkDatatypeContext mcxt+       ; let cxt = fromMaybe (noLoc []) mcxt+       ; return (HsDataDefn { dd_ext = noExtField+                            , dd_ND = new_or_data, dd_cType = cType+                            , dd_ctxt = cxt+                            , dd_cons = data_cons+                            , dd_kindSig = ksig+                            , dd_derivs = maybe_deriv }) }+++mkTySynonym :: SrcSpan+            -> LHsType GhcPs  -- LHS+            -> LHsType GhcPs  -- RHS+            -> P (LTyClDecl GhcPs)+mkTySynonym loc lhs rhs+  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs+       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan+       ; (tyvars, anns) <- checkTyVars (text "type") equalsDots tc tparams+       ; addAnnsAt loc anns -- Add any API Annotations to the top SrcSpan+       ; return (L loc (SynDecl { tcdSExt = noExtField+                                , tcdLName = tc, tcdTyVars = tyvars+                                , tcdFixity = fixity+                                , tcdRhs = rhs })) }++mkStandaloneKindSig+  :: SrcSpan+  -> Located [Located RdrName] -- LHS+  -> LHsKind GhcPs             -- RHS+  -> P (LStandaloneKindSig GhcPs)+mkStandaloneKindSig loc lhs rhs =+  do { vs <- mapM check_lhs_name (unLoc lhs)+     ; v <- check_singular_lhs (reverse vs)+     ; return $ L loc $ StandaloneKindSig noExtField v (mkLHsSigType rhs) }+  where+    check_lhs_name v@(unLoc->name) =+      if isUnqual name && isTcOcc (rdrNameOcc name)+      then return v+      else addFatalError (getLoc v) $+           hang (text "Expected an unqualified type constructor:") 2 (ppr v)+    check_singular_lhs vs =+      case vs of+        [] -> panic "mkStandaloneKindSig: empty left-hand side"+        [v] -> return v+        _ -> addFatalError (getLoc lhs) $+             vcat [ hang (text "Standalone kind signatures do not support multiple names at the moment:")+                       2 (pprWithCommas ppr vs)+                  , text "See https://gitlab.haskell.org/ghc/ghc/issues/16754 for details." ]++mkTyFamInstEqn :: Maybe [LHsTyVarBndr GhcPs]+               -> LHsType GhcPs+               -> LHsType GhcPs+               -> P (TyFamInstEqn GhcPs,[AddAnn])+mkTyFamInstEqn bndrs lhs rhs+  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs+       ; return (mkHsImplicitBndrs+                  (FamEqn { feqn_ext    = noExtField+                          , feqn_tycon  = tc+                          , feqn_bndrs  = bndrs+                          , feqn_pats   = tparams+                          , feqn_fixity = fixity+                          , feqn_rhs    = rhs }),+                 ann) }++mkDataFamInst :: SrcSpan+              -> NewOrData+              -> Maybe (Located CType)+              -> (Maybe ( LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs]+                        , LHsType GhcPs)+              -> Maybe (LHsKind GhcPs)+              -> [LConDecl GhcPs]+              -> HsDeriving GhcPs+              -> P (LInstDecl GhcPs)+mkDataFamInst loc new_or_data cType (mcxt, bndrs, tycl_hdr)+              ksig data_cons maybe_deriv+  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False tycl_hdr+       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan+       ; defn <- mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv+       ; return (L loc (DataFamInstD noExtField (DataFamInstDecl (mkHsImplicitBndrs+                  (FamEqn { feqn_ext    = noExtField+                          , feqn_tycon  = tc+                          , feqn_bndrs  = bndrs+                          , feqn_pats   = tparams+                          , feqn_fixity = fixity+                          , feqn_rhs    = defn }))))) }++mkTyFamInst :: SrcSpan+            -> TyFamInstEqn GhcPs+            -> P (LInstDecl GhcPs)+mkTyFamInst loc eqn+  = return (L loc (TyFamInstD noExtField (TyFamInstDecl eqn)))++mkFamDecl :: SrcSpan+          -> FamilyInfo GhcPs+          -> LHsType GhcPs                   -- LHS+          -> Located (FamilyResultSig GhcPs) -- Optional result signature+          -> Maybe (LInjectivityAnn GhcPs)   -- Injectivity annotation+          -> P (LTyClDecl GhcPs)+mkFamDecl loc info lhs ksig injAnn+  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs+       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan+       ; (tyvars, anns) <- checkTyVars (ppr info) equals_or_where tc tparams+       ; addAnnsAt loc anns -- Add any API Annotations to the top SrcSpan+       ; return (L loc (FamDecl noExtField (FamilyDecl+                                           { fdExt       = noExtField+                                           , fdInfo      = info, fdLName = tc+                                           , fdTyVars    = tyvars+                                           , fdFixity    = fixity+                                           , fdResultSig = ksig+                                           , fdInjectivityAnn = injAnn }))) }+  where+    equals_or_where = case info of+                        DataFamily          -> empty+                        OpenTypeFamily      -> empty+                        ClosedTypeFamily {} -> whereDots++mkSpliceDecl :: LHsExpr GhcPs -> HsDecl GhcPs+-- If the user wrote+--      [pads| ... ]   then return a QuasiQuoteD+--      $(e)           then return a SpliceD+-- but if she wrote, say,+--      f x            then behave as if she'd written $(f x)+--                     ie a SpliceD+--+-- Typed splices are not allowed at the top level, thus we do not represent them+-- as spliced declaration.  See #10945+mkSpliceDecl lexpr@(L loc expr)+  | HsSpliceE _ splice@(HsUntypedSplice {}) <- expr+  = SpliceD noExtField (SpliceDecl noExtField (L loc splice) ExplicitSplice)++  | HsSpliceE _ splice@(HsQuasiQuote {}) <- expr+  = SpliceD noExtField (SpliceDecl noExtField (L loc splice) ExplicitSplice)++  | otherwise+  = SpliceD noExtField (SpliceDecl noExtField (L loc (mkUntypedSplice BareSplice lexpr))+                              ImplicitSplice)++mkRoleAnnotDecl :: SrcSpan+                -> Located RdrName                -- type being annotated+                -> [Located (Maybe FastString)]      -- roles+                -> P (LRoleAnnotDecl GhcPs)+mkRoleAnnotDecl loc tycon roles+  = do { roles' <- mapM parse_role roles+       ; return $ L loc $ RoleAnnotDecl noExtField tycon roles' }+  where+    role_data_type = dataTypeOf (undefined :: Role)+    all_roles = map fromConstr $ dataTypeConstrs role_data_type+    possible_roles = [(fsFromRole role, role) | role <- all_roles]++    parse_role (L loc_role Nothing) = return $ L loc_role Nothing+    parse_role (L loc_role (Just role))+      = case lookup role possible_roles of+          Just found_role -> return $ L loc_role $ Just found_role+          Nothing         ->+            let nearby = fuzzyLookup (unpackFS role)+                  (mapFst unpackFS possible_roles)+            in+            addFatalError loc_role+              (text "Illegal role name" <+> quotes (ppr role) $$+               suggestions nearby)++    suggestions []   = empty+    suggestions [r]  = text "Perhaps you meant" <+> quotes (ppr r)+      -- will this last case ever happen??+    suggestions list = hang (text "Perhaps you meant one of these:")+                       2 (pprWithCommas (quotes . ppr) list)++{- **********************************************************************++  #cvBinds-etc# Converting to @HsBinds@, etc.++  ********************************************************************* -}++-- | Function definitions are restructured here. Each is assumed to be recursive+-- initially, and non recursive definitions are discovered by the dependency+-- analyser.+++--  | Groups together bindings for a single function+cvTopDecls :: OrdList (LHsDecl GhcPs) -> [LHsDecl GhcPs]+cvTopDecls decls = go (fromOL decls)+  where+    go :: [LHsDecl GhcPs] -> [LHsDecl GhcPs]+    go []                     = []+    go ((L l (ValD x b)) : ds)+      = L l' (ValD x b') : go ds'+        where (L l' b', ds') = getMonoBind (L l b) ds+    go (d : ds)                    = d : go ds++-- Declaration list may only contain value bindings and signatures.+cvBindGroup :: OrdList (LHsDecl GhcPs) -> P (HsValBinds GhcPs)+cvBindGroup binding+  = do { (mbs, sigs, fam_ds, tfam_insts+         , dfam_insts, _) <- cvBindsAndSigs binding+       ; ASSERT( null fam_ds && null tfam_insts && null dfam_insts)+         return $ ValBinds noExtField mbs sigs }++cvBindsAndSigs :: OrdList (LHsDecl GhcPs)+  -> P (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs]+          , [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl])+-- Input decls contain just value bindings and signatures+-- and in case of class or instance declarations also+-- associated type declarations. They might also contain Haddock comments.+cvBindsAndSigs fb = go (fromOL fb)+  where+    go []              = return (emptyBag, [], [], [], [], [])+    go ((L l (ValD _ b)) : ds)+      = do { (bs, ss, ts, tfis, dfis, docs) <- go ds'+           ; return (b' `consBag` bs, ss, ts, tfis, dfis, docs) }+      where+        (b', ds') = getMonoBind (L l b) ds+    go ((L l decl) : ds)+      = do { (bs, ss, ts, tfis, dfis, docs) <- go ds+           ; case decl of+               SigD _ s+                 -> return (bs, L l s : ss, ts, tfis, dfis, docs)+               TyClD _ (FamDecl _ t)+                 -> return (bs, ss, L l t : ts, tfis, dfis, docs)+               InstD _ (TyFamInstD { tfid_inst = tfi })+                 -> return (bs, ss, ts, L l tfi : tfis, dfis, docs)+               InstD _ (DataFamInstD { dfid_inst = dfi })+                 -> return (bs, ss, ts, tfis, L l dfi : dfis, docs)+               DocD _ d+                 -> return (bs, ss, ts, tfis, dfis, L l d : docs)+               SpliceD _ d+                 -> addFatalError l $+                    hang (text "Declaration splices are allowed only" <+>+                          text "at the top level:")+                       2 (ppr d)+               _ -> pprPanic "cvBindsAndSigs" (ppr decl) }++-----------------------------------------------------------------------------+-- Group function bindings into equation groups++getMonoBind :: LHsBind GhcPs -> [LHsDecl GhcPs]+  -> (LHsBind GhcPs, [LHsDecl GhcPs])+-- Suppose      (b',ds') = getMonoBind b ds+--      ds is a list of parsed bindings+--      b is a MonoBinds that has just been read off the front++-- Then b' is the result of grouping more equations from ds that+-- belong with b into a single MonoBinds, and ds' is the depleted+-- list of parsed bindings.+--+-- All Haddock comments between equations inside the group are+-- discarded.+--+-- No AndMonoBinds or EmptyMonoBinds here; just single equations++getMonoBind (L loc1 (FunBind { fun_id = fun_id1@(L _ f1)+                             , fun_matches =+                               MG { mg_alts = (L _ mtchs1) } }))+            binds+  | has_args mtchs1+  = go mtchs1 loc1 binds []+  where+    go mtchs loc+       ((L loc2 (ValD _ (FunBind { fun_id = (L _ f2)+                                 , fun_matches =+                                    MG { mg_alts = (L _ mtchs2) } })))+         : binds) _+        | f1 == f2 = go (mtchs2 ++ mtchs)+                        (combineSrcSpans loc loc2) binds []+    go mtchs loc (doc_decl@(L loc2 (DocD {})) : binds) doc_decls+        = let doc_decls' = doc_decl : doc_decls+          in go mtchs (combineSrcSpans loc loc2) binds doc_decls'+    go mtchs loc binds doc_decls+        = ( L loc (makeFunBind fun_id1 (reverse mtchs))+          , (reverse doc_decls) ++ binds)+        -- Reverse the final matches, to get it back in the right order+        -- Do the same thing with the trailing doc comments++getMonoBind bind binds = (bind, binds)++has_args :: [LMatch GhcPs (LHsExpr GhcPs)] -> Bool+has_args []                                  = panic "GHC.Parser.PostProcess.has_args"+has_args (L _ (Match { m_pats = args }) : _) = not (null args)+        -- Don't group together FunBinds if they have+        -- no arguments.  This is necessary now that variable bindings+        -- with no arguments are now treated as FunBinds rather+        -- than pattern bindings (tests/rename/should_fail/rnfail002).++{- **********************************************************************++  #PrefixToHS-utils# Utilities for conversion++  ********************************************************************* -}++{- Note [Parsing data constructors is hard]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++The problem with parsing data constructors is that they look a lot like types.+Compare:++  (s1)   data T = C t1 t2+  (s2)   type T = C t1 t2++Syntactically, there's little difference between these declarations, except in+(s1) 'C' is a data constructor, but in (s2) 'C' is a type constructor.++This similarity would pose no problem if we knew ahead of time if we are+parsing a type or a constructor declaration. Looking at (s1) and (s2), a simple+(but wrong!) rule comes to mind: in 'data' declarations assume we are parsing+data constructors, and in other contexts (e.g. 'type' declarations) assume we+are parsing type constructors.++This simple rule does not work because of two problematic cases:++  (p1)   data T = C t1 t2 :+ t3+  (p2)   data T = C t1 t2 => t3++In (p1) we encounter (:+) and it turns out we are parsing an infix data+declaration, so (C t1 t2) is a type and 'C' is a type constructor.+In (p2) we encounter (=>) and it turns out we are parsing an existential+context, so (C t1 t2) is a constraint and 'C' is a type constructor.++As the result, in order to determine whether (C t1 t2) declares a data+constructor, a type, or a context, we would need unlimited lookahead which+'happy' is not so happy with.++To further complicate matters, the interpretation of (!) and (~) is different+in constructors and types:++  (b1)   type T = C ! D+  (b2)   data T = C ! D+  (b3)   data T = C ! D => E++In (b1) and (b3), (!) is a type operator with two arguments: 'C' and 'D'. At+the same time, in (b2) it is a strictness annotation: 'C' is a data constructor+with a single strict argument 'D'. For the programmer, these cases are usually+easy to tell apart due to whitespace conventions:++  (b2)   data T = C !D         -- no space after the bang hints that+                               -- it is a strictness annotation++For the parser, on the other hand, this whitespace does not matter. We cannot+tell apart (b2) from (b3) until we encounter (=>), so it requires unlimited+lookahead.++The solution that accounts for all of these issues is to initially parse data+declarations and types as a reversed list of TyEl:++  data TyEl = TyElOpr RdrName+            | TyElOpd (HsType GhcPs)+            | ...++For example, both occurrences of (C ! D) in the following example are parsed+into equal lists of TyEl:++  data T = C ! D => C ! D   results in   [ TyElOpd (HsTyVar "D")+                                         , TyElOpr "!"+                                         , TyElOpd (HsTyVar "C") ]++Note that elements are in reverse order. Also, 'C' is parsed as a type+constructor (HsTyVar) even when it is a data constructor. We fix this in+`tyConToDataCon`.++By the time the list of TyEl is assembled, we have looked ahead enough to+decide whether to reduce using `mergeOps` (for types) or `mergeDataCon` (for+data constructors). These functions are where the actual job of parsing is+done.++-}++-- | Reinterpret a type constructor, including type operators, as a data+--   constructor.+-- See Note [Parsing data constructors is hard]+tyConToDataCon :: SrcSpan -> RdrName -> Either (SrcSpan, SDoc) (Located RdrName)+tyConToDataCon loc tc+  | isTcOcc occ || isDataOcc occ+  , isLexCon (occNameFS occ)+  = return (L loc (setRdrNameSpace tc srcDataName))++  | otherwise+  = Left (loc, msg)+  where+    occ = rdrNameOcc tc+    msg = text "Not a data constructor:" <+> quotes (ppr tc)++mkPatSynMatchGroup :: Located RdrName+                   -> Located (OrdList (LHsDecl GhcPs))+                   -> P (MatchGroup GhcPs (LHsExpr GhcPs))+mkPatSynMatchGroup (L loc patsyn_name) (L _ decls) =+    do { matches <- mapM fromDecl (fromOL decls)+       ; when (null matches) (wrongNumberErr loc)+       ; return $ mkMatchGroup FromSource matches }+  where+    fromDecl (L loc decl@(ValD _ (PatBind _+                         pat@(L _ (ConPat NoExtField ln@(L _ name) details))+                               rhs _))) =+        do { unless (name == patsyn_name) $+               wrongNameBindingErr loc decl+           ; match <- case details of+               PrefixCon pats -> return $ Match { m_ext = noExtField+                                                , m_ctxt = ctxt, m_pats = pats+                                                , m_grhss = rhs }+                   where+                     ctxt = FunRhs { mc_fun = ln+                                   , mc_fixity = Prefix+                                   , mc_strictness = NoSrcStrict }++               InfixCon p1 p2 -> return $ Match { m_ext = noExtField+                                                , m_ctxt = ctxt+                                                , m_pats = [p1, p2]+                                                , m_grhss = rhs }+                   where+                     ctxt = FunRhs { mc_fun = ln+                                   , mc_fixity = Infix+                                   , mc_strictness = NoSrcStrict }++               RecCon{} -> recordPatSynErr loc pat+           ; return $ L loc match }+    fromDecl (L loc decl) = extraDeclErr loc decl++    extraDeclErr loc decl =+        addFatalError loc $+        text "pattern synonym 'where' clause must contain a single binding:" $$+        ppr decl++    wrongNameBindingErr loc decl =+      addFatalError loc $+      text "pattern synonym 'where' clause must bind the pattern synonym's name"+      <+> quotes (ppr patsyn_name) $$ ppr decl++    wrongNumberErr loc =+      addFatalError loc $+      text "pattern synonym 'where' clause cannot be empty" $$+      text "In the pattern synonym declaration for: " <+> ppr (patsyn_name)++recordPatSynErr :: SrcSpan -> LPat GhcPs -> P a+recordPatSynErr loc pat =+    addFatalError loc $+    text "record syntax not supported for pattern synonym declarations:" $$+    ppr pat++mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr GhcPs]+                -> Maybe (LHsContext GhcPs) -> HsConDeclDetails GhcPs+                -> ConDecl GhcPs++mkConDeclH98 name mb_forall mb_cxt args+  = ConDeclH98 { con_ext    = noExtField+               , con_name   = name+               , con_forall = noLoc $ isJust mb_forall+               , con_ex_tvs = mb_forall `orElse` []+               , con_mb_cxt = mb_cxt+               , con_args   = args+               , con_doc    = Nothing }++mkGadtDecl :: [Located RdrName]+           -> LHsType GhcPs     -- Always a HsForAllTy+           -> (ConDecl GhcPs, [AddAnn])+mkGadtDecl names ty+  = (ConDeclGADT { con_g_ext  = noExtField+                 , con_names  = names+                 , con_forall = L l $ isLHsForAllTy ty'+                 , con_qvars  = mkHsQTvs tvs+                 , con_mb_cxt = mcxt+                 , con_args   = args+                 , con_res_ty = res_ty+                 , con_doc    = Nothing }+    , anns1 ++ anns2)+  where+    (ty'@(L l _),anns1) = peel_parens ty []+    (tvs, rho) = splitLHsForAllTyInvis ty'+    (mcxt, tau, anns2) = split_rho rho []++    split_rho (L _ (HsQualTy { hst_ctxt = cxt, hst_body = tau })) ann+      = (Just cxt, tau, ann)+    split_rho (L l (HsParTy _ ty)) ann+      = split_rho ty (ann++mkParensApiAnn l)+    split_rho tau                  ann+      = (Nothing, tau, ann)++    (args, res_ty) = split_tau tau++    -- See Note [GADT abstract syntax] in GHC.Hs.Decls+    split_tau (L _ (HsFunTy _ (L loc (HsRecTy _ rf)) res_ty))+      = (RecCon (L loc rf), res_ty)+    split_tau tau+      = (PrefixCon [], tau)++    peel_parens (L l (HsParTy _ ty)) ann = peel_parens ty+                                                       (ann++mkParensApiAnn l)+    peel_parens ty                   ann = (ty, ann)+++setRdrNameSpace :: RdrName -> NameSpace -> RdrName+-- ^ This rather gruesome function is used mainly by the parser.+-- When parsing:+--+-- > data T a = T | T1 Int+--+-- we parse the data constructors as /types/ because of parser ambiguities,+-- so then we need to change the /type constr/ to a /data constr/+--+-- The exact-name case /can/ occur when parsing:+--+-- > data [] a = [] | a : [a]+--+-- For the exact-name case we return an original name.+setRdrNameSpace (Unqual occ) ns = Unqual (setOccNameSpace ns occ)+setRdrNameSpace (Qual m occ) ns = Qual m (setOccNameSpace ns occ)+setRdrNameSpace (Orig m occ) ns = Orig m (setOccNameSpace ns occ)+setRdrNameSpace (Exact n)    ns+  | Just thing <- wiredInNameTyThing_maybe n+  = setWiredInNameSpace thing ns+    -- Preserve Exact Names for wired-in things,+    -- notably tuples and lists++  | isExternalName n+  = Orig (nameModule n) occ++  | otherwise   -- This can happen when quoting and then+                -- splicing a fixity declaration for a type+  = Exact (mkSystemNameAt (nameUnique n) occ (nameSrcSpan n))+  where+    occ = setOccNameSpace ns (nameOccName n)++setWiredInNameSpace :: TyThing -> NameSpace -> RdrName+setWiredInNameSpace (ATyCon tc) ns+  | isDataConNameSpace ns+  = ty_con_data_con tc+  | isTcClsNameSpace ns+  = Exact (getName tc)      -- No-op++setWiredInNameSpace (AConLike (RealDataCon dc)) ns+  | isTcClsNameSpace ns+  = data_con_ty_con dc+  | isDataConNameSpace ns+  = Exact (getName dc)      -- No-op++setWiredInNameSpace thing ns+  = pprPanic "setWiredinNameSpace" (pprNameSpace ns <+> ppr thing)++ty_con_data_con :: TyCon -> RdrName+ty_con_data_con tc+  | isTupleTyCon tc+  , Just dc <- tyConSingleDataCon_maybe tc+  = Exact (getName dc)++  | tc `hasKey` listTyConKey+  = Exact nilDataConName++  | otherwise  -- See Note [setRdrNameSpace for wired-in names]+  = Unqual (setOccNameSpace srcDataName (getOccName tc))++data_con_ty_con :: DataCon -> RdrName+data_con_ty_con dc+  | let tc = dataConTyCon dc+  , isTupleTyCon tc+  = Exact (getName tc)++  | dc `hasKey` nilDataConKey+  = Exact listTyConName++  | otherwise  -- See Note [setRdrNameSpace for wired-in names]+  = Unqual (setOccNameSpace tcClsName (getOccName dc))++-- | Replaces constraint tuple names with corresponding boxed ones.+filterCTuple :: RdrName -> RdrName+filterCTuple (Exact n)+  | Just arity <- cTupleTyConNameArity_maybe n+  = Exact $ tupleTyConName BoxedTuple arity+filterCTuple rdr = rdr+++{- Note [setRdrNameSpace for wired-in names]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In GHC.Types, which declares (:), we have+  infixr 5 :+The ambiguity about which ":" is meant is resolved by parsing it as a+data constructor, but then using dataTcOccs to try the type constructor too;+and that in turn calls setRdrNameSpace to change the name-space of ":" to+tcClsName.  There isn't a corresponding ":" type constructor, but it's painful+to make setRdrNameSpace partial, so we just make an Unqual name instead. It+really doesn't matter!+-}++eitherToP :: Either (SrcSpan, SDoc) a -> P a+-- Adapts the Either monad to the P monad+eitherToP (Left (loc, doc)) = addFatalError loc doc+eitherToP (Right thing)     = return thing++checkTyVars :: SDoc -> SDoc -> Located RdrName -> [LHsTypeArg GhcPs]+            -> P ( LHsQTyVars GhcPs  -- the synthesized type variables+                 , [AddAnn] )        -- action which adds annotations+-- ^ Check whether the given list of type parameters are all type variables+-- (possibly with a kind signature).+checkTyVars pp_what equals_or_where tc tparms+  = do { (tvs, anns) <- fmap unzip $ mapM check tparms+       ; return (mkHsQTvs tvs, concat anns) }+  where+    check (HsTypeArg _ ki@(L loc _))+                              = addFatalError loc $+                                      vcat [ text "Unexpected type application" <+>+                                            text "@" <> ppr ki+                                          , text "In the" <+> pp_what <+>+                                            ptext (sLit "declaration for") <+> quotes (ppr tc)]+    check (HsValArg ty) = chkParens [] ty+    check (HsArgPar sp) = addFatalError sp $+                          vcat [text "Malformed" <+> pp_what+                            <+> text "declaration for" <+> quotes (ppr tc)]+        -- Keep around an action for adjusting the annotations of extra parens+    chkParens :: [AddAnn] -> LHsType GhcPs+              -> P (LHsTyVarBndr GhcPs, [AddAnn])+    chkParens acc (L l (HsParTy _ ty)) = chkParens (mkParensApiAnn l ++ acc) ty+    chkParens acc ty = do+      tv <- chk ty+      return (tv, reverse acc)++        -- Check that the name space is correct!+    chk :: LHsType GhcPs -> P (LHsTyVarBndr GhcPs)+    chk (L l (HsKindSig _ (L lv (HsTyVar _ _ (L _ tv))) k))+        | isRdrTyVar tv    = return (L l (KindedTyVar noExtField (L lv tv) k))+    chk (L l (HsTyVar _ _ (L ltv tv)))+        | isRdrTyVar tv    = return (L l (UserTyVar noExtField (L ltv tv)))+    chk t@(L loc _)+        = addFatalError loc $+                vcat [ text "Unexpected type" <+> quotes (ppr t)+                     , text "In the" <+> pp_what+                       <+> ptext (sLit "declaration for") <+> quotes tc'+                     , vcat[ (text "A" <+> pp_what+                              <+> ptext (sLit "declaration should have form"))+                     , nest 2+                       (pp_what+                        <+> tc'+                        <+> hsep (map text (takeList tparms allNameStrings))+                        <+> equals_or_where) ] ]++    -- Avoid printing a constraint tuple in the error message. Print+    -- a plain old tuple instead (since that's what the user probably+    -- wrote). See #14907+    tc' = ppr $ fmap filterCTuple tc++++whereDots, equalsDots :: SDoc+-- Second argument to checkTyVars+whereDots  = text "where ..."+equalsDots = text "= ..."++checkDatatypeContext :: Maybe (LHsContext GhcPs) -> P ()+checkDatatypeContext Nothing = return ()+checkDatatypeContext (Just c)+    = do allowed <- getBit DatatypeContextsBit+         unless allowed $+             addError (getLoc c)+                 (text "Illegal datatype context (use DatatypeContexts):"+                  <+> pprLHsContext c)++type LRuleTyTmVar = Located RuleTyTmVar+data RuleTyTmVar = RuleTyTmVar (Located RdrName) (Maybe (LHsType GhcPs))+-- ^ Essentially a wrapper for a @RuleBndr GhcPs@++-- turns RuleTyTmVars into RuleBnrs - this is straightforward+mkRuleBndrs :: [LRuleTyTmVar] -> [LRuleBndr GhcPs]+mkRuleBndrs = fmap (fmap cvt_one)+  where cvt_one (RuleTyTmVar v Nothing)    = RuleBndr    noExtField v+        cvt_one (RuleTyTmVar v (Just sig)) =+          RuleBndrSig noExtField v (mkLHsSigWcType sig)++-- turns RuleTyTmVars into HsTyVarBndrs - this is more interesting+mkRuleTyVarBndrs :: [LRuleTyTmVar] -> [LHsTyVarBndr GhcPs]+mkRuleTyVarBndrs = fmap (fmap cvt_one)+  where cvt_one (RuleTyTmVar v Nothing)    = UserTyVar   noExtField (fmap tm_to_ty v)+        cvt_one (RuleTyTmVar v (Just sig))+          = KindedTyVar noExtField (fmap tm_to_ty v) sig+    -- takes something in namespace 'varName' to something in namespace 'tvName'+        tm_to_ty (Unqual occ) = Unqual (setOccNameSpace tvName occ)+        tm_to_ty _ = panic "mkRuleTyVarBndrs"++-- See note [Parsing explicit foralls in Rules] in GHC.Parser+checkRuleTyVarBndrNames :: [LHsTyVarBndr GhcPs] -> P ()+checkRuleTyVarBndrNames = mapM_ (check . fmap hsTyVarName)+  where check (L loc (Unqual occ)) = do+          when ((occNameString occ ==) `any` ["forall","family","role"])+               (addFatalError loc (text $ "parse error on input "+                                    ++ occNameString occ))+        check _ = panic "checkRuleTyVarBndrNames"++checkRecordSyntax :: (MonadP m, Outputable a) => Located a -> m (Located a)+checkRecordSyntax lr@(L loc r)+    = do allowed <- getBit TraditionalRecordSyntaxBit+         unless allowed $ addError loc $+           text "Illegal record syntax (use TraditionalRecordSyntax):" <+> ppr r+         return lr++-- | Check if the gadt_constrlist is empty. Only raise parse error for+-- `data T where` to avoid affecting existing error message, see #8258.+checkEmptyGADTs :: Located ([AddAnn], [LConDecl GhcPs])+                -> P (Located ([AddAnn], [LConDecl GhcPs]))+checkEmptyGADTs gadts@(L span (_, []))           -- Empty GADT declaration.+    = do gadtSyntax <- getBit GadtSyntaxBit   -- GADTs implies GADTSyntax+         unless gadtSyntax $ addError span $ vcat+           [ text "Illegal keyword 'where' in data declaration"+           , text "Perhaps you intended to use GADTs or a similar language"+           , text "extension to enable syntax: data T where"+           ]+         return gadts+checkEmptyGADTs gadts = return gadts              -- Ordinary GADT declaration.++checkTyClHdr :: Bool               -- True  <=> class header+                                   -- False <=> type header+             -> LHsType GhcPs+             -> P (Located RdrName,      -- the head symbol (type or class name)+                   [LHsTypeArg GhcPs],      -- parameters of head symbol+                   LexicalFixity,        -- the declaration is in infix format+                   [AddAnn]) -- API Annotation for HsParTy when stripping parens+-- Well-formedness check and decomposition of type and class heads.+-- Decomposes   T ty1 .. tyn   into    (T, [ty1, ..., tyn])+--              Int :*: Bool   into    (:*:, [Int, Bool])+-- returning the pieces+checkTyClHdr is_cls ty+  = goL ty [] [] Prefix+  where+    goL (L l ty) acc ann fix = go l ty acc ann fix++    -- workaround to define '*' despite StarIsType+    go lp (HsParTy _ (L l (HsStarTy _ isUni))) acc ann fix+      = do { warnStarBndr l+           ; let name = mkOccName tcClsName (starSym isUni)+           ; return (L l (Unqual name), acc, fix, (ann ++ mkParensApiAnn lp)) }++    go _ (HsTyVar _ _ ltc@(L _ tc)) acc ann fix+      | isRdrTc tc               = return (ltc, acc, fix, ann)+    go _ (HsOpTy _ t1 ltc@(L _ tc) t2) acc ann _fix+      | isRdrTc tc               = return (ltc, HsValArg t1:HsValArg t2:acc, Infix, ann)+    go l (HsParTy _ ty)    acc ann fix = goL ty acc (ann ++mkParensApiAnn l) fix+    go _ (HsAppTy _ t1 t2) acc ann fix = goL t1 (HsValArg t2:acc) ann fix+    go _ (HsAppKindTy l ty ki) acc ann fix = goL ty (HsTypeArg l ki:acc) ann fix+    go l (HsTupleTy _ HsBoxedOrConstraintTuple ts) [] ann fix+      = return (L l (nameRdrName tup_name), map HsValArg ts, fix, ann)+      where+        arity = length ts+        tup_name | is_cls    = cTupleTyConName arity+                 | otherwise = getName (tupleTyCon Boxed arity)+          -- See Note [Unit tuples] in GHC.Hs.Types  (TODO: is this still relevant?)+    go l _ _ _ _+      = addFatalError l (text "Malformed head of type or class declaration:"+                          <+> ppr ty)++-- | Yield a parse error if we have a function applied directly to a do block+-- etc. and BlockArguments is not enabled.+checkExpBlockArguments :: LHsExpr GhcPs -> PV ()+checkCmdBlockArguments :: LHsCmd GhcPs -> PV ()+(checkExpBlockArguments, checkCmdBlockArguments) = (checkExpr, checkCmd)+  where+    checkExpr :: LHsExpr GhcPs -> PV ()+    checkExpr expr = case unLoc expr of+      HsDo _ DoExpr _ -> check "do block" expr+      HsDo _ MDoExpr _ -> check "mdo block" expr+      HsLam {} -> check "lambda expression" expr+      HsCase {} -> check "case expression" expr+      HsLamCase {} -> check "lambda-case expression" expr+      HsLet {} -> check "let expression" expr+      HsIf {} -> check "if expression" expr+      HsProc {} -> check "proc expression" expr+      _ -> return ()++    checkCmd :: LHsCmd GhcPs -> PV ()+    checkCmd cmd = case unLoc cmd of+      HsCmdLam {} -> check "lambda command" cmd+      HsCmdCase {} -> check "case command" cmd+      HsCmdIf {} -> check "if command" cmd+      HsCmdLet {} -> check "let command" cmd+      HsCmdDo {} -> check "do command" cmd+      _ -> return ()++    check :: Outputable a => String -> Located a -> PV ()+    check element a = do+      blockArguments <- getBit BlockArgumentsBit+      unless blockArguments $+        addError (getLoc a) $+          text "Unexpected " <> text element <> text " in function application:"+           $$ nest 4 (ppr a)+           $$ text "You could write it with parentheses"+           $$ text "Or perhaps you meant to enable BlockArguments?"++-- | Validate the context constraints and break up a context into a list+-- of predicates.+--+-- @+--     (Eq a, Ord b)        -->  [Eq a, Ord b]+--     Eq a                 -->  [Eq a]+--     (Eq a)               -->  [Eq a]+--     (((Eq a)))           -->  [Eq a]+-- @+checkContext :: LHsType GhcPs -> P ([AddAnn],LHsContext GhcPs)+checkContext (L l orig_t)+  = check [] (L l orig_t)+ where+  check anns (L lp (HsTupleTy _ HsBoxedOrConstraintTuple ts))+    -- (Eq a, Ord b) shows up as a tuple type. Only boxed tuples can+    -- be used as context constraints.+    = return (anns ++ mkParensApiAnn lp,L l ts)                -- Ditto ()++  check anns (L lp1 (HsParTy _ ty))+                                  -- to be sure HsParTy doesn't get into the way+       = check anns' ty+         where anns' = if l == lp1 then anns+                                   else (anns ++ mkParensApiAnn lp1)++  -- no need for anns, returning original+  check _anns t = checkNoDocs msg t *> return ([],L l [L l orig_t])++  msg = text "data constructor context"++-- | Check recursively if there are any 'HsDocTy's in the given type.+-- This only works on a subset of types produced by 'btype_no_ops'+checkNoDocs :: SDoc -> LHsType GhcPs -> P ()+checkNoDocs msg ty = go ty+  where+    go (L _ (HsAppKindTy _ ty ki)) = go ty *> go ki+    go (L _ (HsAppTy _ t1 t2)) = go t1 *> go t2+    go (L l (HsDocTy _ t ds)) = addError l $ hsep+                                  [ text "Unexpected haddock", quotes (ppr ds)+                                  , text "on", msg, quotes (ppr t) ]+    go _ = pure ()++checkImportDecl :: Maybe (Located Token)+                -> Maybe (Located Token)+                -> P ()+checkImportDecl mPre mPost = do+  let whenJust mg f = maybe (pure ()) f mg++  importQualifiedPostEnabled <- getBit ImportQualifiedPostBit++  -- Error if 'qualified' found in postpositive position and+  -- 'ImportQualifiedPost' is not in effect.+  whenJust mPost $ \post ->+    when (not importQualifiedPostEnabled) $+      failOpNotEnabledImportQualifiedPost (getLoc post)++  -- Error if 'qualified' occurs in both pre and postpositive+  -- positions.+  whenJust mPost $ \post ->+    when (isJust mPre) $+      failOpImportQualifiedTwice (getLoc post)++  -- Warn if 'qualified' found in prepositive position and+  -- 'Opt_WarnPrepositiveQualifiedModule' is enabled.+  whenJust mPre $ \pre ->+    warnPrepositiveQualifiedModule (getLoc pre)++-- -------------------------------------------------------------------------+-- Checking Patterns.++-- We parse patterns as expressions and check for valid patterns below,+-- converting the expression into a pattern at the same time.++checkPattern :: Located (PatBuilder GhcPs) -> P (LPat GhcPs)+checkPattern = runPV . checkLPat++checkPattern_msg :: SDoc -> PV (Located (PatBuilder GhcPs)) -> P (LPat GhcPs)+checkPattern_msg msg pp = runPV_msg msg (pp >>= checkLPat)++checkLPat :: Located (PatBuilder GhcPs) -> PV (LPat GhcPs)+checkLPat e@(L l _) = checkPat l e []++checkPat :: SrcSpan -> Located (PatBuilder GhcPs) -> [LPat GhcPs]+         -> PV (LPat GhcPs)+checkPat loc (L l e@(PatBuilderVar (L _ c))) args+  | isRdrDataCon c = return . L loc $ ConPat+      { pat_con_ext = noExtField+      , pat_con = L l c+      , pat_args = PrefixCon args+      }+  | not (null args) && patIsRec c =+      localPV_msg (\_ -> text "Perhaps you intended to use RecursiveDo") $+      patFail l (ppr e)+checkPat loc (L _ (PatBuilderApp f e)) args+  = do p <- checkLPat e+       checkPat loc f (p : args)+checkPat loc (L _ e) []+  = do p <- checkAPat loc e+       return (L loc p)+checkPat loc e _+  = patFail loc (ppr e)++checkAPat :: SrcSpan -> PatBuilder GhcPs -> PV (Pat GhcPs)+checkAPat loc e0 = do+ nPlusKPatterns <- getBit NPlusKPatternsBit+ case e0 of+   PatBuilderPat p -> return p+   PatBuilderVar x -> return (VarPat noExtField x)++   -- Overloaded numeric patterns (e.g. f 0 x = x)+   -- Negation is recorded separately, so that the literal is zero or +ve+   -- NB. Negative *primitive* literals are already handled by the lexer+   PatBuilderOverLit pos_lit -> return (mkNPat (L loc pos_lit) Nothing)++   -- n+k patterns+   PatBuilderOpApp+           (L nloc (PatBuilderVar (L _ n)))+           (L _ plus)+           (L lloc (PatBuilderOverLit lit@(OverLit {ol_val = HsIntegral {}})))+                      | nPlusKPatterns && (plus == plus_RDR)+                      -> return (mkNPlusKPat (L nloc n) (L lloc lit))++   PatBuilderOpApp l (L cl c) r+     | isRdrDataCon c -> do+         l <- checkLPat l+         r <- checkLPat r+         return $ ConPat+           { pat_con_ext = noExtField+           , pat_con = L cl c+           , pat_args = InfixCon l r+           }++   PatBuilderPar e    -> checkLPat e >>= (return . (ParPat noExtField))+   _           -> patFail loc (ppr e0)++placeHolderPunRhs :: DisambECP b => PV (Located b)+-- The RHS of a punned record field will be filled in by the renamer+-- It's better not to make it an error, in case we want to print it when+-- debugging+placeHolderPunRhs = mkHsVarPV (noLoc pun_RDR)++plus_RDR, pun_RDR :: RdrName+plus_RDR = mkUnqual varName (fsLit "+") -- Hack+pun_RDR  = mkUnqual varName (fsLit "pun-right-hand-side")++checkPatField :: LHsRecField GhcPs (Located (PatBuilder GhcPs))+              -> PV (LHsRecField GhcPs (LPat GhcPs))+checkPatField (L l fld) = do p <- checkLPat (hsRecFieldArg fld)+                             return (L l (fld { hsRecFieldArg = p }))++patFail :: SrcSpan -> SDoc -> PV a+patFail loc e = addFatalError loc $ text "Parse error in pattern:" <+> ppr e++patIsRec :: RdrName -> Bool+patIsRec e = e == mkUnqual varName (fsLit "rec")++---------------------------------------------------------------------------+-- Check Equation Syntax++checkValDef :: Located (PatBuilder GhcPs)+            -> Maybe (LHsType GhcPs)+            -> Located (a,GRHSs GhcPs (LHsExpr GhcPs))+            -> P ([AddAnn],HsBind GhcPs)++checkValDef lhs (Just sig) grhss+        -- x :: ty = rhs  parses as a *pattern* binding+  = do lhs' <- runPV $ mkHsTySigPV (combineLocs lhs sig) lhs sig >>= checkLPat+       checkPatBind lhs' grhss++checkValDef lhs Nothing g@(L l (_,grhss))+  = do  { mb_fun <- isFunLhs lhs+        ; case mb_fun of+            Just (fun, is_infix, pats, ann) ->+              checkFunBind NoSrcStrict ann (getLoc lhs)+                           fun is_infix pats (L l grhss)+            Nothing -> do+              lhs' <- checkPattern lhs+              checkPatBind lhs' g }++checkFunBind :: SrcStrictness+             -> [AddAnn]+             -> SrcSpan+             -> Located RdrName+             -> LexicalFixity+             -> [Located (PatBuilder GhcPs)]+             -> Located (GRHSs GhcPs (LHsExpr GhcPs))+             -> P ([AddAnn],HsBind GhcPs)+checkFunBind strictness ann lhs_loc fun is_infix pats (L rhs_span grhss)+  = do  ps <- mapM checkPattern pats+        let match_span = combineSrcSpans lhs_loc rhs_span+        -- Add back the annotations stripped from any HsPar values in the lhs+        -- mapM_ (\a -> a match_span) ann+        return (ann, makeFunBind fun+                  [L match_span (Match { m_ext = noExtField+                                       , m_ctxt = FunRhs+                                           { mc_fun    = fun+                                           , mc_fixity = is_infix+                                           , mc_strictness = strictness }+                                       , m_pats = ps+                                       , m_grhss = grhss })])+        -- The span of the match covers the entire equation.+        -- That isn't quite right, but it'll do for now.++makeFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)]+            -> HsBind GhcPs+-- Like GHC.Hs.Utils.mkFunBind, but we need to be able to set the fixity too+makeFunBind fn ms+  = FunBind { fun_ext = noExtField,+              fun_id = fn,+              fun_matches = mkMatchGroup FromSource ms,+              fun_tick = [] }++-- See Note [FunBind vs PatBind]+checkPatBind :: LPat GhcPs+             -> Located (a,GRHSs GhcPs (LHsExpr GhcPs))+             -> P ([AddAnn],HsBind GhcPs)+checkPatBind lhs (L match_span (_,grhss))+    | BangPat _ p <- unLoc lhs+    , VarPat _ v <- unLoc p+    = return ([], makeFunBind v [L match_span (m v)])+  where+    m v = Match { m_ext = noExtField+                , m_ctxt = FunRhs { mc_fun    = L (getLoc lhs) (unLoc v)+                                  , mc_fixity = Prefix+                                  , mc_strictness = SrcStrict }+                , m_pats = []+                , m_grhss = grhss }++checkPatBind lhs (L _ (_,grhss))+  = return ([],PatBind noExtField lhs grhss ([],[]))++checkValSigLhs :: LHsExpr GhcPs -> P (Located RdrName)+checkValSigLhs (L _ (HsVar _ lrdr@(L _ v)))+  | isUnqual v+  , not (isDataOcc (rdrNameOcc v))+  = return lrdr++checkValSigLhs lhs@(L l _)+  = addFatalError l ((text "Invalid type signature:" <+>+                       ppr lhs <+> text ":: ...")+                      $$ text hint)+  where+    hint | foreign_RDR `looks_like` lhs+         = "Perhaps you meant to use ForeignFunctionInterface?"+         | default_RDR `looks_like` lhs+         = "Perhaps you meant to use DefaultSignatures?"+         | pattern_RDR `looks_like` lhs+         = "Perhaps you meant to use PatternSynonyms?"+         | otherwise+         = "Should be of form <variable> :: <type>"++    -- A common error is to forget the ForeignFunctionInterface flag+    -- so check for that, and suggest.  cf #3805+    -- Sadly 'foreign import' still barfs 'parse error' because+    --  'import' is a keyword+    looks_like s (L _ (HsVar _ (L _ v))) = v == s+    looks_like s (L _ (HsApp _ lhs _))   = looks_like s lhs+    looks_like _ _                       = False++    foreign_RDR = mkUnqual varName (fsLit "foreign")+    default_RDR = mkUnqual varName (fsLit "default")+    pattern_RDR = mkUnqual varName (fsLit "pattern")++checkDoAndIfThenElse+  :: (Outputable a, Outputable b, Outputable c)+  => Located a -> Bool -> b -> Bool -> Located c -> PV ()+checkDoAndIfThenElse guardExpr semiThen thenExpr semiElse elseExpr+ | semiThen || semiElse+    = do doAndIfThenElse <- getBit DoAndIfThenElseBit+         unless doAndIfThenElse $ do+             addError (combineLocs guardExpr elseExpr)+                            (text "Unexpected semi-colons in conditional:"+                          $$ nest 4 expr+                          $$ text "Perhaps you meant to use DoAndIfThenElse?")+ | otherwise            = return ()+    where pprOptSemi True  = semi+          pprOptSemi False = empty+          expr = text "if"   <+> ppr guardExpr <> pprOptSemi semiThen <+>+                 text "then" <+> ppr thenExpr  <> pprOptSemi semiElse <+>+                 text "else" <+> ppr elseExpr++isFunLhs :: Located (PatBuilder GhcPs)+      -> P (Maybe (Located RdrName, LexicalFixity, [Located (PatBuilder GhcPs)],[AddAnn]))+-- A variable binding is parsed as a FunBind.+-- Just (fun, is_infix, arg_pats) if e is a function LHS+isFunLhs e = go e [] []+ where+   go (L loc (PatBuilderVar (L _ f))) es ann+       | not (isRdrDataCon f)        = return (Just (L loc f, Prefix, es, ann))+   go (L _ (PatBuilderApp f e)) es       ann = go f (e:es) ann+   go (L l (PatBuilderPar e))   es@(_:_) ann = go e es (ann ++ mkParensApiAnn l)+   go (L loc (PatBuilderOpApp l (L loc' op) r)) es ann+        | not (isRdrDataCon op)         -- We have found the function!+        = return (Just (L loc' op, Infix, (l:r:es), ann))+        | otherwise                     -- Infix data con; keep going+        = do { mb_l <- go l es ann+             ; case mb_l of+                 Just (op', Infix, j : k : es', ann')+                   -> return (Just (op', Infix, j : op_app : es', ann'))+                   where+                     op_app = L loc (PatBuilderOpApp k+                               (L loc' op) r)+                 _ -> return Nothing }+   go _ _ _ = return Nothing++-- | Either an operator or an operand.+data TyEl = TyElOpr RdrName | TyElOpd (HsType GhcPs)+          | TyElKindApp SrcSpan (LHsType GhcPs)+          -- See Note [TyElKindApp SrcSpan interpretation]+          | TyElUnpackedness ([AddAnn], SourceText, SrcUnpackedness)+          | TyElDocPrev HsDocString+++{- Note [TyElKindApp SrcSpan interpretation]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++A TyElKindApp captures type application written in haskell as++    @ Foo++where Foo is some type.++The SrcSpan reflects both elements, and there are AnnAt and AnnVal API+Annotations attached to this SrcSpan for the specific locations of+each within it.+-}++instance Outputable TyEl where+  ppr (TyElOpr name) = ppr name+  ppr (TyElOpd ty) = ppr ty+  ppr (TyElKindApp _ ki) = text "@" <> ppr ki+  ppr (TyElUnpackedness (_, _, unpk)) = ppr unpk+  ppr (TyElDocPrev doc) = ppr doc++-- | Extract a strictness/unpackedness annotation from the front of a reversed+-- 'TyEl' list.+pUnpackedness+  :: [Located TyEl] -- reversed TyEl+  -> Maybe ( SrcSpan+           , [AddAnn]+           , SourceText+           , SrcUnpackedness+           , [Located TyEl] {- remaining TyEl -})+pUnpackedness (L l x1 : xs)+  | TyElUnpackedness (anns, prag, unpk) <- x1+  = Just (l, anns, prag, unpk, xs)+pUnpackedness _ = Nothing++pBangTy+  :: LHsType GhcPs  -- a type to be wrapped inside HsBangTy+  -> [Located TyEl] -- reversed TyEl+  -> ( Bool           {- has a strict mark been consumed? -}+     , LHsType GhcPs  {- the resulting BangTy -}+     , P ()           {- add annotations -}+     , [Located TyEl] {- remaining TyEl -})+pBangTy lt@(L l1 _) xs =+  case pUnpackedness xs of+    Nothing -> (False, lt, pure (), xs)+    Just (l2, anns, prag, unpk, xs') ->+      let bl = combineSrcSpans l1 l2+          bt = addUnpackedness (prag, unpk) lt+      in (True, L bl bt, addAnnsAt bl anns, xs')++mkBangTy :: SrcStrictness -> LHsType GhcPs -> HsType GhcPs+mkBangTy strictness =+  HsBangTy noExtField (HsSrcBang NoSourceText NoSrcUnpack strictness)++addUnpackedness :: (SourceText, SrcUnpackedness) -> LHsType GhcPs -> HsType GhcPs+addUnpackedness (prag, unpk) (L _ (HsBangTy x bang t))+  | HsSrcBang NoSourceText NoSrcUnpack strictness <- bang+  = HsBangTy x (HsSrcBang prag unpk strictness) t+addUnpackedness (prag, unpk) t+  = HsBangTy noExtField (HsSrcBang prag unpk NoSrcStrict) t++-- | Merge a /reversed/ and /non-empty/ soup of operators and operands+--   into a type.+--+-- User input: @F x y + G a b * X@+-- Input to 'mergeOps': [X, *, b, a, G, +, y, x, F]+-- Output corresponds to what the user wrote assuming all operators are of the+-- same fixity and right-associative.+--+-- It's a bit silly that we're doing it at all, as the renamer will have to+-- rearrange this, and it'd be easier to keep things separate.+--+-- See Note [Parsing data constructors is hard]+mergeOps :: [Located TyEl] -> P (LHsType GhcPs)+mergeOps ((L l1 (TyElOpd t)) : xs)+  | (_, t', addAnns, xs') <- pBangTy (L l1 t) xs+  , null xs' -- We accept a BangTy only when there are no preceding TyEl.+  = addAnns >> return t'+mergeOps all_xs = go (0 :: Int) [] id all_xs+  where+    -- NB. When modifying clauses in 'go', make sure that the reasoning in+    -- Note [Non-empty 'acc' in mergeOps clause [end]] is still correct.++    -- clause [unpk]:+    -- handle (NO)UNPACK pragmas+    go k acc ops_acc ((L l (TyElUnpackedness (anns, unpkSrc, unpk))):xs) =+      if not (null acc) && null xs+      then do { acc' <- eitherToP $ mergeOpsAcc acc+              ; let a = ops_acc acc'+                    strictMark = HsSrcBang unpkSrc unpk NoSrcStrict+                    bl = combineSrcSpans l (getLoc a)+                    bt = HsBangTy noExtField strictMark a+              ; addAnnsAt bl anns+              ; return (L bl bt) }+      else addFatalError l unpkError+      where+        unpkSDoc = case unpkSrc of+          NoSourceText -> ppr unpk+          SourceText str -> text str <> text " #-}"+        unpkError+          | not (null xs) = unpkSDoc <+> text "cannot appear inside a type."+          | null acc && k == 0 = unpkSDoc <+> text "must be applied to a type."+          | otherwise =+              -- See Note [Impossible case in mergeOps clause [unpk]]+              panic "mergeOps.UNPACK: impossible position"++    -- clause [doc]:+    -- we do not expect to encounter any docs+    go _ _ _ ((L l (TyElDocPrev _)):_) =+      failOpDocPrev l++    -- clause [opr]:+    -- when we encounter an operator, we must have accumulated+    -- something for its rhs, and there must be something left+    -- to build its lhs.+    go k acc ops_acc ((L l (TyElOpr op)):xs) =+      if null acc || null (filter isTyElOpd xs)+        then failOpFewArgs (L l op)+        else do { acc' <- eitherToP (mergeOpsAcc acc)+                ; go (k + 1) [] (\c -> mkLHsOpTy c (L l op) (ops_acc acc')) xs }+      where+        isTyElOpd (L _ (TyElOpd _)) = True+        isTyElOpd _ = False++    -- clause [opd]:+    -- whenever an operand is encountered, it is added to the accumulator+    go k acc ops_acc ((L l (TyElOpd a)):xs) = go k (HsValArg (L l a):acc) ops_acc xs++    -- clause [tyapp]:+    -- whenever a type application is encountered, it is added to the accumulator+    go k acc ops_acc ((L _ (TyElKindApp l a)):xs) = go k (HsTypeArg l a:acc) ops_acc xs++    -- clause [end]+    -- See Note [Non-empty 'acc' in mergeOps clause [end]]+    go _ acc ops_acc [] = do { acc' <- eitherToP (mergeOpsAcc acc)+                             ; return (ops_acc acc') }++mergeOpsAcc :: [HsArg (LHsType GhcPs) (LHsKind GhcPs)]+         -> Either (SrcSpan, SDoc) (LHsType GhcPs)+mergeOpsAcc [] = panic "mergeOpsAcc: empty input"+mergeOpsAcc (HsTypeArg _ (L loc ki):_)+  = Left (loc, text "Unexpected type application:" <+> ppr ki)+mergeOpsAcc (HsValArg ty : xs) = go1 ty xs+  where+    go1 :: LHsType GhcPs+        -> [HsArg (LHsType GhcPs) (LHsKind GhcPs)]+        -> Either (SrcSpan, SDoc) (LHsType GhcPs)+    go1 lhs []     = Right lhs+    go1 lhs (x:xs) = case x of+        HsValArg ty -> go1 (mkHsAppTy lhs ty) xs+        HsTypeArg loc ki -> let ty = mkHsAppKindTy loc lhs ki+                            in go1 ty xs+        HsArgPar _ -> go1 lhs xs+mergeOpsAcc (HsArgPar _: xs) = mergeOpsAcc xs++{- Note [Impossible case in mergeOps clause [unpk]]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+This case should never occur. Let us consider all possible+variations of 'acc', 'xs', and 'k':++  acc          xs        k+==============================+  null   |    null       0      -- "must be applied to a type"+  null   |  not null     0      -- "must be applied to a type"+not null |    null       0      -- successful parse+not null |  not null     0      -- "cannot appear inside a type"+  null   |    null      >0      -- handled in clause [opr]+  null   |  not null    >0      -- "cannot appear inside a type"+not null |    null      >0      -- successful parse+not null |  not null    >0      -- "cannot appear inside a type"++The (null acc && null xs && k>0) case is handled in clause [opr]+by the following check:++    if ... || null (filter isTyElOpd xs)+     then failOpFewArgs (L l op)++We know that this check has been performed because k>0, and by+the time we reach the end of the list (null xs), the only way+for (null acc) to hold is that there was not a single TyElOpd+between the operator and the end of the list. But this case is+caught by the check and reported as 'failOpFewArgs'.+-}++{- Note [Non-empty 'acc' in mergeOps clause [end]]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In clause [end] we need to know that 'acc' is non-empty to call 'mergeAcc'+without a check.++Running 'mergeOps' with an empty input list is forbidden, so we do not consider+this possibility. This means we'll hit at least one other clause before we+reach clause [end].++* Clauses [unpk] and [doc] do not call 'go' recursively, so we cannot hit+  clause [end] from there.+* Clause [opd] makes 'acc' non-empty, so if we hit clause [end] after it, 'acc'+  will be non-empty.+* Clause [opr] checks that (filter isTyElOpd xs) is not null - so we are going+  to hit clause [opd] at least once before we reach clause [end], making 'acc'+  non-empty.+* There are no other clauses.++Therefore, it is safe to omit a check for non-emptiness of 'acc' in clause+[end].++-}++pInfixSide :: [Located TyEl] -> Maybe (LHsType GhcPs, P (), [Located TyEl])+pInfixSide ((L l (TyElOpd t)):xs)+  | (True, t', addAnns, xs') <- pBangTy (L l t) xs+  = Just (t', addAnns, xs')+pInfixSide (el:xs1)+  | Just t1 <- pLHsTypeArg el+  = go [t1] xs1+   where+     go :: [HsArg (LHsType GhcPs) (LHsKind GhcPs)]+        -> [Located TyEl] -> Maybe (LHsType GhcPs, P (), [Located TyEl])+     go acc (el:xs)+       | Just t <- pLHsTypeArg el+       = go (t:acc) xs+     go acc xs = case mergeOpsAcc acc of+       Left _ -> Nothing+       Right acc' -> Just (acc', pure (), xs)+pInfixSide _ = Nothing++pLHsTypeArg :: Located TyEl -> Maybe (HsArg (LHsType GhcPs) (LHsKind GhcPs))+pLHsTypeArg (L l (TyElOpd a)) = Just (HsValArg (L l a))+pLHsTypeArg (L _ (TyElKindApp l a)) = Just (HsTypeArg l a)+pLHsTypeArg _ = Nothing++pDocPrev :: [Located TyEl] -> (Maybe LHsDocString, [Located TyEl])+pDocPrev = go Nothing+  where+    go mTrailingDoc ((L l (TyElDocPrev doc)):xs) =+      go (mTrailingDoc `mplus` Just (L l doc)) xs+    go mTrailingDoc xs = (mTrailingDoc, xs)++orErr :: Maybe a -> b -> Either b a+orErr (Just a) _ = Right a+orErr Nothing b = Left b++-- | Merge a /reversed/ and /non-empty/ soup of operators and operands+--   into a data constructor.+--+-- User input: @C !A B -- ^ doc@+-- Input to 'mergeDataCon': ["doc", B, !A, C]+-- Output: (C, PrefixCon [!A, B], "doc")+--+-- See Note [Parsing data constructors is hard]+mergeDataCon+      :: [Located TyEl]+      -> P ( Located RdrName         -- constructor name+           , HsConDeclDetails GhcPs  -- constructor field information+           , Maybe LHsDocString      -- docstring to go on the constructor+           )+mergeDataCon all_xs =+  do { (addAnns, a) <- eitherToP res+     ; addAnns+     ; return a }+  where+    -- We start by splitting off the trailing documentation comment,+    -- if any exists.+    (mTrailingDoc, all_xs') = pDocPrev all_xs++    -- Determine whether the trailing documentation comment exists and is the+    -- only docstring in this constructor declaration.+    --+    -- When true, it means that it applies to the constructor itself:+    --    data T = C+    --             A+    --             B -- ^ Comment on C (singleDoc == True)+    --+    -- When false, it means that it applies to the last field:+    --    data T = C -- ^ Comment on C+    --             A -- ^ Comment on A+    --             B -- ^ Comment on B (singleDoc == False)+    singleDoc = isJust mTrailingDoc &&+                null [ () | (L _ (TyElDocPrev _)) <- all_xs' ]++    -- The result of merging the list of reversed TyEl into a+    -- data constructor, along with [AddAnn].+    res = goFirst all_xs'++    -- Take the trailing docstring into account when interpreting+    -- the docstring near the constructor.+    --+    --    data T = C -- ^ docstring right after C+    --             A+    --             B -- ^ trailing docstring+    --+    -- 'mkConDoc' must be applied to the docstring right after C, so that it+    -- falls back to the trailing docstring when appropriate (see singleDoc).+    mkConDoc mDoc | singleDoc = mDoc `mplus` mTrailingDoc+                  | otherwise = mDoc++    -- The docstring for the last field of a data constructor.+    trailingFieldDoc | singleDoc = Nothing+                     | otherwise = mTrailingDoc++    goFirst [ L l (TyElOpd (HsTyVar _ _ (L _ tc))) ]+      = do { data_con <- tyConToDataCon l tc+           ; return (pure (), (data_con, PrefixCon [], mTrailingDoc)) }+    goFirst ((L l (TyElOpd (HsRecTy _ fields))):xs)+      | (mConDoc, xs') <- pDocPrev xs+      , [ L l' (TyElOpd (HsTyVar _ _ (L _ tc))) ] <- xs'+      = do { data_con <- tyConToDataCon l' tc+           ; let mDoc = mTrailingDoc `mplus` mConDoc+           ; return (pure (), (data_con, RecCon (L l fields), mDoc)) }+    goFirst [L l (TyElOpd (HsTupleTy _ HsBoxedOrConstraintTuple ts))]+      = return ( pure ()+               , ( L l (getRdrName (tupleDataCon Boxed (length ts)))+                 , PrefixCon ts+                 , mTrailingDoc ) )+    goFirst ((L l (TyElOpd t)):xs)+      | (_, t', addAnns, xs') <- pBangTy (L l t) xs+      = go addAnns Nothing [mkLHsDocTyMaybe t' trailingFieldDoc] xs'+    goFirst (L l (TyElKindApp _ _):_)+      = goInfix Monoid.<> Left (l, kindAppErr)+    goFirst xs+      = go (pure ()) mTrailingDoc [] xs++    go addAnns mLastDoc ts [ L l (TyElOpd (HsTyVar _ _ (L _ tc))) ]+      = do { data_con <- tyConToDataCon l tc+           ; return (addAnns, (data_con, PrefixCon ts, mkConDoc mLastDoc)) }+    go addAnns mLastDoc ts ((L l (TyElDocPrev doc)):xs) =+      go addAnns (mLastDoc `mplus` Just (L l doc)) ts xs+    go addAnns mLastDoc ts ((L l (TyElOpd t)):xs)+      | (_, t', addAnns', xs') <- pBangTy (L l t) xs+      , t'' <- mkLHsDocTyMaybe t' mLastDoc+      = go (addAnns >> addAnns') Nothing (t'':ts) xs'+    go _ _ _ ((L _ (TyElOpr _)):_) =+      -- Encountered an operator: backtrack to the beginning and attempt+      -- to parse as an infix definition.+      goInfix+    go _ _ _ (L l (TyElKindApp _ _):_) =  goInfix Monoid.<> Left (l, kindAppErr)+    go _ _ _ _ = Left malformedErr+      where+        malformedErr =+          ( foldr combineSrcSpans noSrcSpan (map getLoc all_xs')+          , text "Cannot parse data constructor" <+>+            text "in a data/newtype declaration:" $$+            nest 2 (hsep . reverse $ map ppr all_xs'))++    goInfix =+      do { let xs0 = all_xs'+         ; (rhs_t, rhs_addAnns, xs1) <- pInfixSide xs0 `orErr` malformedErr+         ; let (mOpDoc, xs2) = pDocPrev xs1+         ; (op, xs3) <- case xs2 of+              (L l (TyElOpr op)) : xs3 ->+                do { data_con <- tyConToDataCon l op+                   ; return (data_con, xs3) }+              _ -> Left malformedErr+         ; let (mLhsDoc, xs4) = pDocPrev xs3+         ; (lhs_t, lhs_addAnns, xs5) <- pInfixSide xs4 `orErr` malformedErr+         ; unless (null xs5) (Left malformedErr)+         ; let rhs = mkLHsDocTyMaybe rhs_t trailingFieldDoc+               lhs = mkLHsDocTyMaybe lhs_t mLhsDoc+               addAnns = lhs_addAnns >> rhs_addAnns+         ; return (addAnns, (op, InfixCon lhs rhs, mkConDoc mOpDoc)) }+      where+        malformedErr =+          ( foldr combineSrcSpans noSrcSpan (map getLoc all_xs')+          , text "Cannot parse an infix data constructor" <+>+            text "in a data/newtype declaration:" $$+            nest 2 (hsep . reverse $ map ppr all_xs'))++    kindAppErr =+      text "Unexpected kind application" <+>+      text "in a data/newtype declaration:" $$+      nest 2 (hsep . reverse $ map ppr all_xs')++---------------------------------------------------------------------------+-- | Check for monad comprehensions+--+-- If the flag MonadComprehensions is set, return a 'MonadComp' context,+-- otherwise use the usual 'ListComp' context++checkMonadComp :: PV (HsStmtContext GhcRn)+checkMonadComp = do+    monadComprehensions <- getBit MonadComprehensionsBit+    return $ if monadComprehensions+                then MonadComp+                else ListComp++-- -------------------------------------------------------------------------+-- Expression/command/pattern ambiguity.+-- See Note [Ambiguous syntactic categories]+--++-- See Note [Parser-Validator]+-- See Note [Ambiguous syntactic categories]+--+-- This newtype is required to avoid impredicative types in monadic+-- productions. That is, in a production that looks like+--+--    | ... {% return (ECP ...) }+--+-- we are dealing with+--    P ECP+-- whereas without a newtype we would be dealing with+--    P (forall b. DisambECP b => PV (Located b))+--+newtype ECP =+  ECP { runECP_PV :: forall b. DisambECP b => PV (Located b) }++runECP_P :: DisambECP b => ECP -> P (Located b)+runECP_P p = runPV (runECP_PV p)++ecpFromExp :: LHsExpr GhcPs -> ECP+ecpFromExp a = ECP (ecpFromExp' a)++ecpFromCmd :: LHsCmd GhcPs -> ECP+ecpFromCmd a = ECP (ecpFromCmd' a)++-- | Disambiguate infix operators.+-- See Note [Ambiguous syntactic categories]+class DisambInfixOp b where+  mkHsVarOpPV :: Located RdrName -> PV (Located b)+  mkHsConOpPV :: Located RdrName -> PV (Located b)+  mkHsInfixHolePV :: SrcSpan -> PV (Located b)++instance DisambInfixOp (HsExpr GhcPs) where+  mkHsVarOpPV v = return $ L (getLoc v) (HsVar noExtField v)+  mkHsConOpPV v = return $ L (getLoc v) (HsVar noExtField v)+  mkHsInfixHolePV l = return $ L l hsHoleExpr++instance DisambInfixOp RdrName where+  mkHsConOpPV (L l v) = return $ L l v+  mkHsVarOpPV (L l v) = return $ L l v+  mkHsInfixHolePV l =+    addFatalError l $ text "Invalid infix hole, expected an infix operator"++-- | Disambiguate constructs that may appear when we do not know ahead of time whether we are+-- parsing an expression, a command, or a pattern.+-- See Note [Ambiguous syntactic categories]+class b ~ (Body b) GhcPs => DisambECP b where+  -- | See Note [Body in DisambECP]+  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.+  ecpFromExp' :: LHsExpr GhcPs -> PV (Located b)+  -- | Disambiguate "\... -> ..." (lambda)+  mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located b) -> PV (Located b)+  -- | Disambiguate "let ... in ..."+  mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located b -> PV (Located b)+  -- | Infix operator representation+  type InfixOp b+  -- | Bring superclass constraints on InfixOp into scope.+  -- See Note [UndecidableSuperClasses for associated types]+  superInfixOp :: (DisambInfixOp (InfixOp b) => PV (Located b )) -> PV (Located b)+  -- | Disambiguate "f # x" (infix operator)+  mkHsOpAppPV :: SrcSpan -> Located b -> Located (InfixOp b) -> Located b -> PV (Located b)+  -- | Disambiguate "case ... of ..."+  mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located b) -> PV (Located b)+  -- | Disambiguate @\\case ...@ (lambda case)+  mkHsLamCasePV :: SrcSpan -> MatchGroup GhcPs (Located b) -> PV (Located b)+  -- | Function argument representation+  type FunArg b+  -- | Bring superclass constraints on FunArg into scope.+  -- See Note [UndecidableSuperClasses for associated types]+  superFunArg :: (DisambECP (FunArg b) => PV (Located b)) -> PV (Located b)+  -- | Disambiguate "f x" (function application)+  mkHsAppPV :: SrcSpan -> Located b -> Located (FunArg b) -> PV (Located b)+  -- | Disambiguate "if ... then ... else ..."+  mkHsIfPV :: SrcSpan+         -> LHsExpr GhcPs+         -> Bool  -- semicolon?+         -> Located b+         -> Bool  -- semicolon?+         -> Located b+         -> PV (Located b)+  -- | Disambiguate "do { ... }" (do notation)+  mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located b)] -> PV (Located b)+  -- | Disambiguate "( ... )" (parentheses)+  mkHsParPV :: SrcSpan -> Located b -> PV (Located b)+  -- | Disambiguate a variable "f" or a data constructor "MkF".+  mkHsVarPV :: Located RdrName -> PV (Located b)+  -- | Disambiguate a monomorphic literal+  mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located b)+  -- | Disambiguate an overloaded literal+  mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located b)+  -- | Disambiguate a wildcard+  mkHsWildCardPV :: SrcSpan -> PV (Located b)+  -- | Disambiguate "a :: t" (type annotation)+  mkHsTySigPV :: SrcSpan -> Located b -> LHsType GhcPs -> PV (Located b)+  -- | Disambiguate "[a,b,c]" (list syntax)+  mkHsExplicitListPV :: SrcSpan -> [Located b] -> PV (Located b)+  -- | Disambiguate "$(...)" and "[quasi|...|]" (TH splices)+  mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located b)+  -- | Disambiguate "f { a = b, ... }" syntax (record construction and record updates)+  mkHsRecordPV ::+    SrcSpan ->+    SrcSpan ->+    Located b ->+    ([LHsRecField GhcPs (Located b)], Maybe SrcSpan) ->+    PV (Located b)+  -- | Disambiguate "-a" (negation)+  mkHsNegAppPV :: SrcSpan -> Located b -> PV (Located b)+  -- | Disambiguate "(# a)" (right operator section)+  mkHsSectionR_PV :: SrcSpan -> Located (InfixOp b) -> Located b -> PV (Located b)+  -- | Disambiguate "(a -> b)" (view pattern)+  mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located b -> PV (Located b)+  -- | Disambiguate "a@b" (as-pattern)+  mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located b -> PV (Located b)+  -- | Disambiguate "~a" (lazy pattern)+  mkHsLazyPatPV :: SrcSpan -> Located b -> PV (Located b)+  -- | Disambiguate "!a" (bang pattern)+  mkHsBangPatPV :: SrcSpan -> Located b -> PV (Located b)+  -- | Disambiguate tuple sections and unboxed sums+  mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple b -> PV (Located b)+  -- | Validate infixexp LHS to reject unwanted {-# SCC ... #-} pragmas+  rejectPragmaPV :: Located b -> PV ()+++{- Note [UndecidableSuperClasses for associated types]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+(This Note is about the code in GHC, not about the user code that we are parsing)++Assume we have a class C with an associated type T:++  class C a where+    type T a+    ...++If we want to add 'C (T a)' as a superclass, we need -XUndecidableSuperClasses:++  {-# LANGUAGE UndecidableSuperClasses #-}+  class C (T a) => C a where+    type T a+    ...++Unfortunately, -XUndecidableSuperClasses don't work all that well, sometimes+making GHC loop. The workaround is to bring this constraint into scope+manually with a helper method:++  class C a where+    type T a+    superT :: (C (T a) => r) -> r++In order to avoid ambiguous types, 'r' must mention 'a'.++For consistency, we use this approach for all constraints on associated types,+even when -XUndecidableSuperClasses are not required.+-}++{- 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 :: Type ->+*). To satisfy this requirement, we say that (b ~ Body b GhcPs) in the+superclass constraints of DisambECP.++The alternative is to change mkBodyStmt, mkBindStmt, unguardedRHS, etc, to drop+this requirement. It is possible and would allow removing the type index of+PatBuilder, but leads to worse type inference, breaking some code in the+typechecker.+-}++instance DisambECP (HsCmd GhcPs) where+  type Body (HsCmd GhcPs) = HsCmd+  ecpFromCmd' = return+  ecpFromExp' (L l e) = cmdFail l (ppr e)+  mkHsLamPV l mg = return $ L l (HsCmdLam noExtField mg)+  mkHsLetPV l bs e = return $ L l (HsCmdLet noExtField bs e)+  type InfixOp (HsCmd GhcPs) = HsExpr GhcPs+  superInfixOp m = m+  mkHsOpAppPV l c1 op c2 = do+    let cmdArg c = L (getLoc c) $ HsCmdTop noExtField c+    return $ L l $ HsCmdArrForm noExtField op Infix Nothing [cmdArg c1, cmdArg c2]+  mkHsCasePV l c mg = return $ L l (HsCmdCase noExtField c mg)+  mkHsLamCasePV l mg = return $ L l (HsCmdLamCase noExtField mg)+  type FunArg (HsCmd GhcPs) = HsExpr GhcPs+  superFunArg m = m+  mkHsAppPV l c e = do+    checkCmdBlockArguments c+    checkExpBlockArguments e+    return $ L l (HsCmdApp noExtField c e)+  mkHsIfPV l c semi1 a semi2 b = do+    checkDoAndIfThenElse c semi1 a semi2 b+    return $ L l (mkHsCmdIf c a b)+  mkHsDoPV l stmts = return $ L l (HsCmdDo noExtField stmts)+  mkHsParPV l c = return $ L l (HsCmdPar noExtField c)+  mkHsVarPV (L l v) = cmdFail l (ppr v)+  mkHsLitPV (L l a) = cmdFail l (ppr a)+  mkHsOverLitPV (L l a) = cmdFail l (ppr a)+  mkHsWildCardPV l = cmdFail l (text "_")+  mkHsTySigPV l a sig = cmdFail l (ppr a <+> text "::" <+> ppr sig)+  mkHsExplicitListPV l xs = cmdFail l $+    brackets (fsep (punctuate comma (map ppr xs)))+  mkHsSplicePV (L l sp) = cmdFail l (ppr sp)+  mkHsRecordPV l _ a (fbinds, ddLoc) = cmdFail l $+    ppr a <+> ppr (mk_rec_fields fbinds ddLoc)+  mkHsNegAppPV l a = cmdFail l (text "-" <> ppr a)+  mkHsSectionR_PV l op c = cmdFail l $+    let pp_op = fromMaybe (panic "cannot print infix operator")+                          (ppr_infix_expr (unLoc op))+    in pp_op <> ppr c+  mkHsViewPatPV l a b = cmdFail l $+    ppr a <+> text "->" <+> ppr b+  mkHsAsPatPV l v c = cmdFail l $+    pprPrefixOcc (unLoc v) <> text "@" <> ppr c+  mkHsLazyPatPV l c = cmdFail l $+    text "~" <> ppr c+  mkHsBangPatPV l c = cmdFail l $+    text "!" <> ppr c+  mkSumOrTuplePV l boxity a = cmdFail l (pprSumOrTuple boxity a)+  rejectPragmaPV _ = return ()++cmdFail :: SrcSpan -> SDoc -> PV a+cmdFail loc e = addFatalError loc $+  hang (text "Parse error in command:") 2 (ppr e)++instance DisambECP (HsExpr GhcPs) where+  type Body (HsExpr GhcPs) = HsExpr+  ecpFromCmd' (L l c) = do+    addError l $ vcat+      [ text "Arrow command found where an expression was expected:",+        nest 2 (ppr c) ]+    return (L l hsHoleExpr)+  ecpFromExp' = return+  mkHsLamPV l mg = return $ L l (HsLam noExtField mg)+  mkHsLetPV l bs c = return $ L l (HsLet noExtField bs c)+  type InfixOp (HsExpr GhcPs) = HsExpr GhcPs+  superInfixOp m = m+  mkHsOpAppPV l e1 op e2 = do+    return $ L l $ OpApp noExtField e1 op e2+  mkHsCasePV l e mg = return $ L l (HsCase noExtField e mg)+  mkHsLamCasePV l mg = return $ L l (HsLamCase noExtField mg)+  type FunArg (HsExpr GhcPs) = HsExpr GhcPs+  superFunArg m = m+  mkHsAppPV l e1 e2 = do+    checkExpBlockArguments e1+    checkExpBlockArguments e2+    return $ L l (HsApp noExtField e1 e2)+  mkHsIfPV l c semi1 a semi2 b = do+    checkDoAndIfThenElse c semi1 a semi2 b+    return $ L l (mkHsIf c a b)+  mkHsDoPV l stmts = return $ L l (HsDo noExtField DoExpr stmts)+  mkHsParPV l e = return $ L l (HsPar noExtField e)+  mkHsVarPV v@(getLoc -> l) = return $ L l (HsVar noExtField v)+  mkHsLitPV (L l a) = return $ L l (HsLit noExtField a)+  mkHsOverLitPV (L l a) = return $ L l (HsOverLit noExtField a)+  mkHsWildCardPV l = return $ L l hsHoleExpr+  mkHsTySigPV l a sig = return $ L l (ExprWithTySig noExtField a (mkLHsSigWcType sig))+  mkHsExplicitListPV l xs = return $ L l (ExplicitList noExtField Nothing xs)+  mkHsSplicePV sp = return $ mapLoc (HsSpliceE noExtField) sp+  mkHsRecordPV l lrec a (fbinds, ddLoc) = do+    r <- mkRecConstrOrUpdate a lrec (fbinds, ddLoc)+    checkRecordSyntax (L l r)+  mkHsNegAppPV l a = return $ L l (NegApp noExtField a noSyntaxExpr)+  mkHsSectionR_PV l op e = return $ L l (SectionR noExtField op e)+  mkHsViewPatPV l a b = patSynErr "View pattern" l (ppr a <+> text "->" <+> ppr b) empty+  mkHsAsPatPV l v e =+    patSynErr "@-pattern" l (pprPrefixOcc (unLoc v) <> text "@" <> ppr e) $+    text "Type application syntax requires a space before '@'"+  mkHsLazyPatPV l e = patSynErr "Lazy pattern" l (text "~" <> ppr e) $+    text "Did you mean to add a space after the '~'?"+  mkHsBangPatPV l e = patSynErr "Bang pattern" l (text "!" <> ppr e) $+    text "Did you mean to add a space after the '!'?"+  mkSumOrTuplePV = mkSumOrTupleExpr+  rejectPragmaPV (L _ (OpApp _ _ _ e)) =+    -- assuming left-associative parsing of operators+    rejectPragmaPV e+  rejectPragmaPV (L l (HsPragE _ prag _)) =+    addError l $+      hang (text "A pragma is not allowed in this position:") 2 (ppr prag)+  rejectPragmaPV _ = return ()++patSynErr :: String -> SrcSpan -> SDoc -> SDoc -> PV (LHsExpr GhcPs)+patSynErr item l e explanation =+  do { addError l $+        sep [text item <+> text "in expression context:",+             nest 4 (ppr e)] $$+        explanation+     ; return (L l hsHoleExpr) }++hsHoleExpr :: HsExpr (GhcPass id)+hsHoleExpr = HsUnboundVar noExtField (mkVarOcc "_")++-- | See Note [Ambiguous syntactic categories] and Note [PatBuilder]+data PatBuilder p+  = PatBuilderPat (Pat p)+  | PatBuilderPar (Located (PatBuilder p))+  | PatBuilderApp (Located (PatBuilder p)) (Located (PatBuilder p))+  | PatBuilderOpApp (Located (PatBuilder p)) (Located RdrName) (Located (PatBuilder p))+  | PatBuilderVar (Located RdrName)+  | PatBuilderOverLit (HsOverLit GhcPs)++instance Outputable (PatBuilder GhcPs) where+  ppr (PatBuilderPat p) = ppr p+  ppr (PatBuilderPar (L _ p)) = parens (ppr p)+  ppr (PatBuilderApp (L _ p1) (L _ p2)) = ppr p1 <+> ppr p2+  ppr (PatBuilderOpApp (L _ p1) op (L _ p2)) = ppr p1 <+> ppr op <+> ppr p2+  ppr (PatBuilderVar v) = ppr v+  ppr (PatBuilderOverLit l) = ppr l++instance DisambECP (PatBuilder GhcPs) where+  type Body (PatBuilder GhcPs) = PatBuilder+  ecpFromCmd' (L l c) =+    addFatalError l $+      text "Command syntax in pattern:" <+> ppr c+  ecpFromExp' (L l e) =+    addFatalError l $+      text "Expression syntax in pattern:" <+> ppr e+  mkHsLamPV l _ = addFatalError l $+    text "Lambda-syntax in pattern." $$+    text "Pattern matching on functions is not possible."+  mkHsLetPV l _ _ = addFatalError l $ text "(let ... in ...)-syntax in pattern"+  type InfixOp (PatBuilder GhcPs) = RdrName+  superInfixOp m = m+  mkHsOpAppPV l p1 op p2 = return $ L l $ PatBuilderOpApp p1 op p2+  mkHsCasePV l _ _ = addFatalError l $ text "(case ... of ...)-syntax in pattern"+  mkHsLamCasePV l _ = addFatalError l $ text "(\\case ...)-syntax in pattern"+  type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs+  superFunArg m = m+  mkHsAppPV l p1 p2 = return $ L l (PatBuilderApp p1 p2)+  mkHsIfPV l _ _ _ _ _ = addFatalError l $ text "(if ... then ... else ...)-syntax in pattern"+  mkHsDoPV l _ = addFatalError l $ text "do-notation in pattern"+  mkHsParPV l p = return $ L l (PatBuilderPar p)+  mkHsVarPV v@(getLoc -> l) = return $ L l (PatBuilderVar v)+  mkHsLitPV lit@(L l a) = do+    checkUnboxedStringLitPat lit+    return $ L l (PatBuilderPat (LitPat noExtField a))+  mkHsOverLitPV (L l a) = return $ L l (PatBuilderOverLit a)+  mkHsWildCardPV l = return $ L l (PatBuilderPat (WildPat noExtField))+  mkHsTySigPV l b sig = do+    p <- checkLPat b+    return $ L l (PatBuilderPat (SigPat noExtField p (mkLHsSigWcType sig)))+  mkHsExplicitListPV l xs = do+    ps <- traverse checkLPat xs+    return (L l (PatBuilderPat (ListPat noExtField ps)))+  mkHsSplicePV (L l sp) = return $ L l (PatBuilderPat (SplicePat noExtField sp))+  mkHsRecordPV l _ a (fbinds, ddLoc) = do+    r <- mkPatRec a (mk_rec_fields fbinds ddLoc)+    checkRecordSyntax (L l r)+  mkHsNegAppPV l (L lp p) = do+    lit <- case p of+      PatBuilderOverLit pos_lit -> return (L lp pos_lit)+      _ -> patFail l (text "-" <> ppr p)+    return $ L l (PatBuilderPat (mkNPat lit (Just noSyntaxExpr)))+  mkHsSectionR_PV l op p = patFail l (pprInfixOcc (unLoc op) <> ppr p)+  mkHsViewPatPV l a b = do+    p <- checkLPat b+    return $ L l (PatBuilderPat (ViewPat noExtField a p))+  mkHsAsPatPV l v e = do+    p <- checkLPat e+    return $ L l (PatBuilderPat (AsPat noExtField v p))+  mkHsLazyPatPV l e = do+    p <- checkLPat e+    return $ L l (PatBuilderPat (LazyPat noExtField p))+  mkHsBangPatPV l e = do+    p <- checkLPat e+    let pb = BangPat noExtField p+    hintBangPat l pb+    return $ L l (PatBuilderPat pb)+  mkSumOrTuplePV = mkSumOrTuplePat+  rejectPragmaPV _ = return ()++checkUnboxedStringLitPat :: Located (HsLit GhcPs) -> PV ()+checkUnboxedStringLitPat (L loc lit) =+  case lit of+    HsStringPrim _ _  -- Trac #13260+      -> addFatalError loc (text "Illegal unboxed string literal in pattern:" $$ ppr lit)+    _ -> return ()++mkPatRec ::+  Located (PatBuilder GhcPs) ->+  HsRecFields GhcPs (Located (PatBuilder GhcPs)) ->+  PV (PatBuilder GhcPs)+mkPatRec (unLoc -> PatBuilderVar c) (HsRecFields fs dd)+  | isRdrDataCon (unLoc c)+  = do fs <- mapM checkPatField fs+       return $ PatBuilderPat $ ConPat+         { pat_con_ext = noExtField+         , pat_con = c+         , pat_args = RecCon (HsRecFields fs dd)+         }+mkPatRec p _ =+  addFatalError (getLoc p) $ text "Not a record constructor:" <+> ppr p++{- Note [Ambiguous syntactic categories]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++There are places in the grammar where we do not know whether we are parsing an+expression or a pattern without unlimited lookahead (which we do not have in+'happy'):++View patterns:++    f (Con a b     ) = ...  -- 'Con a b' is a pattern+    f (Con a b -> x) = ...  -- 'Con a b' is an expression++do-notation:++    do { Con a b <- x } -- 'Con a b' is a pattern+    do { Con a b }      -- 'Con a b' is an expression++Guards:++    x | True <- p && q = ...  -- 'True' is a pattern+    x | True           = ...  -- 'True' is an expression++Top-level value/function declarations (FunBind/PatBind):++    f ! a         -- TH splice+    f ! a = ...   -- function declaration++    Until we encounter the = sign, we don't know if it's a top-level+    TemplateHaskell splice where ! is used, or if it's a function declaration+    where ! is bound.++There are also places in the grammar where we do not know whether we are+parsing an expression or a command:++    proc x -> do { (stuff) -< x }   -- 'stuff' is an expression+    proc x -> do { (stuff) }        -- 'stuff' is a command++    Until we encounter arrow syntax (-<) we don't know whether to parse 'stuff'+    as an expression or a command.++In fact, do-notation is subject to both ambiguities:++    proc x -> do { (stuff) -< x }        -- 'stuff' is an expression+    proc x -> do { (stuff) <- f -< x }   -- 'stuff' is a pattern+    proc x -> do { (stuff) }             -- 'stuff' is a command++There are many possible solutions to this problem. For an overview of the ones+we decided against, see Note [Resolving parsing ambiguities: non-taken alternatives]++The solution that keeps basic definitions (such as HsExpr) clean, keeps the+concerns local to the parser, and does not require duplication of hsSyn types,+or an extra pass over the entire AST, is to parse into an overloaded+parser-validator (a so-called tagless final encoding):++    class DisambECP b where ...+    instance DisambECP (HsCmd GhcPs) where ...+    instance DisambECP (HsExp GhcPs) where ...+    instance DisambECP (PatBuilder GhcPs) where ...++The 'DisambECP' class contains functions to build and validate 'b'. For example,+to add parentheses we have:++  mkHsParPV :: DisambECP b => SrcSpan -> Located b -> PV (Located b)++'mkHsParPV' will wrap the inner value in HsCmdPar for commands, HsPar for+expressions, and 'PatBuilderPar' for patterns (later transformed into ParPat,+see Note [PatBuilder]).++Consider the 'alts' production used to parse case-of alternatives:++  alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }+    : alts1     { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+    | ';' alts  { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }++We abstract over LHsExpr GhcPs, and it becomes:++  alts :: { forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])) }+    : alts1     { $1 >>= \ $1 ->+                  return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+    | ';' alts  { $2 >>= \ $2 ->+                  return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }++Compared to the initial definition, the added bits are:++    forall b. DisambECP b => PV ( ... ) -- in the type signature+    $1 >>= \ $1 -> return $             -- in one reduction rule+    $2 >>= \ $2 -> return $             -- in another reduction rule++The overhead is constant relative to the size of the rest of the reduction+rule, so this approach scales well to large parser productions.++Note that we write ($1 >>= \ $1 -> ...), so the second $1 is in a binding+position and shadows the previous $1. We can do this because internally+'happy' desugars $n to happy_var_n, and the rationale behind this idiom+is to be able to write (sLL $1 $>) later on. The alternative would be to+write this as ($1 >>= \ fresh_name -> ...), but then we couldn't refer+to the last fresh name as $>.+-}+++{- Note [Resolving parsing ambiguities: non-taken alternatives]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++Alternative I, extra constructors in GHC.Hs.Expr+------------------------------------------------+We could add extra constructors to HsExpr to represent command-specific and+pattern-specific syntactic constructs. Under this scheme, we parse patterns+and commands as expressions and rejig later.  This is what GHC used to do, and+it polluted 'HsExpr' with irrelevant constructors:++  * for commands: 'HsArrForm', 'HsArrApp'+  * for patterns: 'EWildPat', 'EAsPat', 'EViewPat', 'ELazyPat'++(As of now, we still do that for patterns, but we plan to fix it).++There are several issues with this:++  * The implementation details of parsing are leaking into hsSyn definitions.++  * Code that uses HsExpr has to panic on these impossible-after-parsing cases.++  * HsExpr is arbitrarily selected as the extension basis. Why not extend+    HsCmd or HsPat with extra constructors instead?++Alternative II, extra constructors in GHC.Hs.Expr for GhcPs+-----------------------------------------------------------+We could address some of the problems with Alternative I by using Trees That+Grow and extending HsExpr only in the GhcPs pass. However, GhcPs corresponds to+the output of parsing, not to its intermediate results, so we wouldn't want+them there either.++Alternative III, extra constructors in GHC.Hs.Expr for GhcPrePs+---------------------------------------------------------------+We could introduce a new pass, GhcPrePs, to keep GhcPs pristine.+Unfortunately, creating a new pass would significantly bloat conversion code+and slow down the compiler by adding another linear-time pass over the entire+AST. For example, in order to build HsExpr GhcPrePs, we would need to build+HsLocalBinds GhcPrePs (as part of HsLet), and we never want HsLocalBinds+GhcPrePs.+++Alternative IV, sum type and bottom-up data flow+------------------------------------------------+Expressions and commands are disjoint. There are no user inputs that could be+interpreted as either an expression or a command depending on outer context:++  5        -- definitely an expression+  x -< y   -- definitely a command++Even though we have both 'HsLam' and 'HsCmdLam', we can look at+the body to disambiguate:++  \p -> 5        -- definitely an expression+  \p -> x -< y   -- definitely a command++This means we could use a bottom-up flow of information to determine+whether we are parsing an expression or a command, using a sum type+for intermediate results:++  Either (LHsExpr GhcPs) (LHsCmd GhcPs)++There are two problems with this:++  * We cannot handle the ambiguity between expressions and+    patterns, which are not disjoint.++  * Bottom-up flow of information leads to poor error messages. Consider++        if ... then 5 else (x -< y)++    Do we report that '5' is not a valid command or that (x -< y) is not a+    valid expression?  It depends on whether we want the entire node to be+    'HsIf' or 'HsCmdIf', and this information flows top-down, from the+    surrounding parsing context (are we in 'proc'?)++Alternative V, backtracking with parser combinators+---------------------------------------------------+One might think we could sidestep the issue entirely by using a backtracking+parser and doing something along the lines of (try pExpr <|> pPat).++Turns out, this wouldn't work very well, as there can be patterns inside+expressions (e.g. via 'case', 'let', 'do') and expressions inside patterns+(e.g. view patterns). To handle this, we would need to backtrack while+backtracking, and unbound levels of backtracking lead to very fragile+performance.++Alternative VI, an intermediate data type+-----------------------------------------+There are common syntactic elements of expressions, commands, and patterns+(e.g. all of them must have balanced parentheses), and we can capture this+common structure in an intermediate data type, Frame:++data Frame+  = FrameVar RdrName+    -- ^ Identifier: Just, map, BS.length+  | FrameTuple [LTupArgFrame] Boxity+    -- ^ Tuple (section): (a,b) (a,b,c) (a,,) (,a,)+  | FrameTySig LFrame (LHsSigWcType GhcPs)+    -- ^ Type signature: x :: ty+  | FramePar (SrcSpan, SrcSpan) LFrame+    -- ^ Parentheses+  | FrameIf LFrame LFrame LFrame+    -- ^ If-expression: if p then x else y+  | FrameCase LFrame [LFrameMatch]+    -- ^ Case-expression: case x of { p1 -> e1; p2 -> e2 }+  | FrameDo (HsStmtContext GhcRn) [LFrameStmt]+    -- ^ Do-expression: do { s1; a <- s2; s3 }+  ...+  | FrameExpr (HsExpr GhcPs)   -- unambiguously an expression+  | FramePat (HsPat GhcPs)     -- unambiguously a pattern+  | FrameCommand (HsCmd GhcPs) -- unambiguously a command++To determine which constructors 'Frame' needs to have, we take the union of+intersections between HsExpr, HsCmd, and HsPat.++The intersection between HsPat and HsExpr:++  HsPat  =  VarPat   | TuplePat      | SigPat        | ParPat   | ...+  HsExpr =  HsVar    | ExplicitTuple | ExprWithTySig | HsPar    | ...+  -------------------------------------------------------------------+  Frame  =  FrameVar | FrameTuple    | FrameTySig    | FramePar | ...++The intersection between HsCmd and HsExpr:++  HsCmd  = HsCmdIf | HsCmdCase | HsCmdDo | HsCmdPar+  HsExpr = HsIf    | HsCase    | HsDo    | HsPar+  ------------------------------------------------+  Frame = FrameIf  | FrameCase | FrameDo | FramePar++The intersection between HsCmd and HsPat:++  HsPat  = ParPat   | ...+  HsCmd  = HsCmdPar | ...+  -----------------------+  Frame  = FramePar | ...++Take the union of each intersection and this yields the final 'Frame' data+type. The problem with this approach is that we end up duplicating a good+portion of hsSyn:++    Frame         for  HsExpr, HsPat, HsCmd+    TupArgFrame   for  HsTupArg+    FrameMatch    for  Match+    FrameStmt     for  StmtLR+    FrameGRHS     for  GRHS+    FrameGRHSs    for  GRHSs+    ...++Alternative VII, a product type+-------------------------------+We could avoid the intermediate representation of Alternative VI by parsing+into a product of interpretations directly:++    -- See Note [Parser-Validator]+    type ExpCmdPat = ( PV (LHsExpr GhcPs)+                     , PV (LHsCmd GhcPs)+                     , PV (LHsPat GhcPs) )++This means that in positions where we do not know whether to produce+expression, a pattern, or a command, we instead produce a parser-validator for+each possible option.++Then, as soon as we have parsed far enough to resolve the ambiguity, we pick+the appropriate component of the product, discarding the rest:++    checkExpOf3 (e, _, _) = e  -- interpret as an expression+    checkCmdOf3 (_, c, _) = c  -- interpret as a command+    checkPatOf3 (_, _, p) = p  -- interpret as a pattern++We can easily define ambiguities between arbitrary subsets of interpretations.+For example, when we know ahead of type that only an expression or a command is+possible, but not a pattern, we can use a smaller type:++    -- See Note [Parser-Validator]+    type ExpCmd = (PV (LHsExpr GhcPs), PV (LHsCmd GhcPs))++    checkExpOf2 (e, _) = e  -- interpret as an expression+    checkCmdOf2 (_, c) = c  -- interpret as a command++However, there is a slight problem with this approach, namely code duplication+in parser productions. Consider the 'alts' production used to parse case-of+alternatives:++  alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }+    : alts1     { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+    | ';' alts  { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }++Under the new scheme, we have to completely duplicate its type signature and+each reduction rule:++  alts :: { ( PV (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)])) -- as an expression+            , PV (Located ([AddAnn],[LMatch GhcPs (LHsCmd GhcPs)]))  -- as a command+            ) }+    : alts1+        { ( checkExpOf2 $1 >>= \ $1 ->+            return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1)+          , checkCmdOf2 $1 >>= \ $1 ->+            return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1)+          ) }+    | ';' alts+        { ( checkExpOf2 $2 >>= \ $2 ->+            return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2)+          , checkCmdOf2 $2 >>= \ $2 ->+            return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2)+          ) }++And the same goes for other productions: 'altslist', 'alts1', 'alt', 'alt_rhs',+'ralt', 'gdpats', 'gdpat', 'exp', ... and so on. That is a lot of code!++Alternative VIII, a function from a GADT+----------------------------------------+We could avoid code duplication of the Alternative VII by representing the product+as a function from a GADT:++    data ExpCmdG b where+      ExpG :: ExpCmdG HsExpr+      CmdG :: ExpCmdG HsCmd++    type ExpCmd = forall b. ExpCmdG b -> PV (Located (b GhcPs))++    checkExp :: ExpCmd -> PV (LHsExpr GhcPs)+    checkCmd :: ExpCmd -> PV (LHsCmd GhcPs)+    checkExp f = f ExpG  -- interpret as an expression+    checkCmd f = f CmdG  -- interpret as a command++Consider the 'alts' production used to parse case-of alternatives:++  alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }+    : alts1     { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+    | ';' alts  { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }++We abstract over LHsExpr, and it becomes:++  alts :: { forall b. ExpCmdG b -> PV (Located ([AddAnn],[LMatch GhcPs (Located (b GhcPs))])) }+    : alts1+        { \tag -> $1 tag >>= \ $1 ->+                  return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+    | ';' alts+        { \tag -> $2 tag >>= \ $2 ->+                  return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }++Note that 'ExpCmdG' is a singleton type, the value is completely+determined by the type:++  when (b~HsExpr),  tag = ExpG+  when (b~HsCmd),   tag = CmdG++This is a clear indication that we can use a class to pass this value behind+the scenes:++  class    ExpCmdI b      where expCmdG :: ExpCmdG b+  instance ExpCmdI HsExpr where expCmdG = ExpG+  instance ExpCmdI HsCmd  where expCmdG = CmdG++And now the 'alts' production is simplified, as we no longer need to+thread 'tag' explicitly:++  alts :: { forall b. ExpCmdI b => PV (Located ([AddAnn],[LMatch GhcPs (Located (b GhcPs))])) }+    : alts1     { $1 >>= \ $1 ->+                  return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+    | ';' alts  { $2 >>= \ $2 ->+                  return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }++This encoding works well enough, but introduces an extra GADT unlike the+tagless final encoding, and there's no need for this complexity.++-}++{- Note [PatBuilder]+~~~~~~~~~~~~~~~~~~~~+Unlike HsExpr or HsCmd, the Pat type cannot accommodate all intermediate forms,+so we introduce the notion of a PatBuilder.++Consider a pattern like this:++  Con a b c++We parse arguments to "Con" one at a time in the  fexp aexp  parser production,+building the result with mkHsAppPV, so the intermediate forms are:++  1. Con+  2. Con a+  3. Con a b+  4. Con a b c++In 'HsExpr', we have 'HsApp', so the intermediate forms are represented like+this (pseudocode):++  1. "Con"+  2. HsApp "Con" "a"+  3. HsApp (HsApp "Con" "a") "b"+  3. HsApp (HsApp (HsApp "Con" "a") "b") "c"++Similarly, in 'HsCmd' we have 'HsCmdApp'. In 'Pat', however, what we have+instead is 'ConPatIn', which is very awkward to modify and thus unsuitable for+the intermediate forms.++We also need an intermediate representation to postpone disambiguation between+FunBind and PatBind. Consider:++  a `Con` b = ...+  a `fun` b = ...++How do we know that (a `Con` b) is a PatBind but (a `fun` b) is a FunBind? We+learn this by inspecting an intermediate representation in 'isFunLhs' and+seeing that 'Con' is a data constructor but 'f' is not. We need an intermediate+representation capable of representing both a FunBind and a PatBind, so Pat is+insufficient.++PatBuilder is an extension of Pat that is capable of representing intermediate+parsing results for patterns and function bindings:++  data PatBuilder p+    = PatBuilderPat (Pat p)+    | PatBuilderApp (Located (PatBuilder p)) (Located (PatBuilder p))+    | PatBuilderOpApp (Located (PatBuilder p)) (Located RdrName) (Located (PatBuilder p))+    ...++It can represent any pattern via 'PatBuilderPat', but it also has a variety of+other constructors which were added by following a simple principle: we never+pattern match on the pattern stored inside 'PatBuilderPat'.+-}++---------------------------------------------------------------------------+-- Miscellaneous utilities++-- | Check if a fixity is valid. We support bypassing the usual bound checks+-- for some special operators.+checkPrecP+        :: Located (SourceText,Int)             -- ^ precedence+        -> Located (OrdList (Located RdrName))  -- ^ operators+        -> P ()+checkPrecP (L l (_,i)) (L _ ol)+ | 0 <= i, i <= maxPrecedence = pure ()+ | all specialOp ol = pure ()+ | otherwise = addFatalError l (text ("Precedence out of range: " ++ show i))+  where+    specialOp op = unLoc op `elem` [ eqTyCon_RDR+                                   , getRdrName funTyCon ]++mkRecConstrOrUpdate+        :: LHsExpr GhcPs+        -> SrcSpan+        -> ([LHsRecField GhcPs (LHsExpr GhcPs)], Maybe SrcSpan)+        -> PV (HsExpr GhcPs)++mkRecConstrOrUpdate (L l (HsVar _ (L _ c))) _ (fs,dd)+  | isRdrDataCon c+  = return (mkRdrRecordCon (L l c) (mk_rec_fields fs dd))+mkRecConstrOrUpdate exp _ (fs,dd)+  | Just dd_loc <- dd = addFatalError dd_loc (text "You cannot use `..' in a record update")+  | otherwise = return (mkRdrRecordUpd exp (map (fmap mk_rec_upd_field) fs))++mkRdrRecordUpd :: LHsExpr GhcPs -> [LHsRecUpdField GhcPs] -> HsExpr GhcPs+mkRdrRecordUpd exp flds+  = RecordUpd { rupd_ext  = noExtField+              , rupd_expr = exp+              , rupd_flds = flds }++mkRdrRecordCon :: Located RdrName -> HsRecordBinds GhcPs -> HsExpr GhcPs+mkRdrRecordCon con flds+  = RecordCon { rcon_ext = noExtField, rcon_con_name = con, rcon_flds = flds }++mk_rec_fields :: [LHsRecField id arg] -> Maybe SrcSpan -> HsRecFields id arg+mk_rec_fields fs Nothing = HsRecFields { rec_flds = fs, rec_dotdot = Nothing }+mk_rec_fields fs (Just s)  = HsRecFields { rec_flds = fs+                                     , rec_dotdot = Just (L s (length fs)) }++mk_rec_upd_field :: HsRecField GhcPs (LHsExpr GhcPs) -> HsRecUpdField GhcPs+mk_rec_upd_field (HsRecField (L loc (FieldOcc _ rdr)) arg pun)+  = HsRecField (L loc (Unambiguous noExtField rdr)) arg pun++mkInlinePragma :: SourceText -> (InlineSpec, RuleMatchInfo) -> Maybe Activation+               -> InlinePragma+-- The (Maybe Activation) is because the user can omit+-- the activation spec (and usually does)+mkInlinePragma src (inl, match_info) mb_act+  = InlinePragma { inl_src = src -- Note [Pragma source text] in GHC.Types.Basic+                 , inl_inline = inl+                 , inl_sat    = Nothing+                 , inl_act    = act+                 , inl_rule   = match_info }+  where+    act = case mb_act of+            Just act -> act+            Nothing  -> -- No phase specified+                        case inl of+                          NoInline -> NeverActive+                          _other   -> AlwaysActive++-----------------------------------------------------------------------------+-- utilities for foreign declarations++-- construct a foreign import declaration+--+mkImport :: Located CCallConv+         -> Located Safety+         -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs)+         -> P (HsDecl GhcPs)+mkImport cconv safety (L loc (StringLiteral esrc entity), v, ty) =+    case unLoc cconv of+      CCallConv          -> mkCImport+      CApiConv           -> mkCImport+      StdCallConv        -> mkCImport+      PrimCallConv       -> mkOtherImport+      JavaScriptCallConv -> mkOtherImport+  where+    -- Parse a C-like entity string of the following form:+    --   "[static] [chname] [&] [cid]" | "dynamic" | "wrapper"+    -- If 'cid' is missing, the function name 'v' is used instead as symbol+    -- name (cf section 8.5.1 in Haskell 2010 report).+    mkCImport = do+      let e = unpackFS entity+      case parseCImport cconv safety (mkExtName (unLoc v)) e (L loc esrc) of+        Nothing         -> addFatalError loc (text "Malformed entity string")+        Just importSpec -> returnSpec importSpec++    -- currently, all the other import conventions only support a symbol name in+    -- the entity string. If it is missing, we use the function name instead.+    mkOtherImport = returnSpec importSpec+      where+        entity'    = if nullFS entity+                        then mkExtName (unLoc v)+                        else entity+        funcTarget = CFunction (StaticTarget esrc entity' Nothing True)+        importSpec = CImport cconv safety Nothing funcTarget (L loc esrc)++    returnSpec spec = return $ ForD noExtField $ ForeignImport+          { fd_i_ext  = noExtField+          , fd_name   = v+          , fd_sig_ty = ty+          , fd_fi     = spec+          }++++-- the string "foo" is ambiguous: either a header or a C identifier.  The+-- C identifier case comes first in the alternatives below, so we pick+-- that one.+parseCImport :: Located CCallConv -> Located Safety -> FastString -> String+             -> Located SourceText+             -> Maybe ForeignImport+parseCImport cconv safety nm str sourceText =+ listToMaybe $ map fst $ filter (null.snd) $+     readP_to_S parse str+ where+   parse = do+       skipSpaces+       r <- choice [+          string "dynamic" >> return (mk Nothing (CFunction DynamicTarget)),+          string "wrapper" >> return (mk Nothing CWrapper),+          do optional (token "static" >> skipSpaces)+             ((mk Nothing <$> cimp nm) ++++              (do h <- munch1 hdr_char+                  skipSpaces+                  mk (Just (Header (SourceText h) (mkFastString h)))+                      <$> cimp nm))+         ]+       skipSpaces+       return r++   token str = do _ <- string str+                  toks <- look+                  case toks of+                      c : _+                       | id_char c -> pfail+                      _            -> return ()++   mk h n = CImport cconv safety h n sourceText++   hdr_char c = not (isSpace c)+   -- header files are filenames, which can contain+   -- pretty much any char (depending on the platform),+   -- so just accept any non-space character+   id_first_char c = isAlpha    c || c == '_'+   id_char       c = isAlphaNum c || c == '_'++   cimp nm = (ReadP.char '&' >> skipSpaces >> CLabel <$> cid)+             +++ (do isFun <- case unLoc cconv of+                               CApiConv ->+                                  option True+                                         (do token "value"+                                             skipSpaces+                                             return False)+                               _ -> return True+                     cid' <- cid+                     return (CFunction (StaticTarget NoSourceText cid'+                                        Nothing isFun)))+          where+            cid = return nm ++++                  (do c  <- satisfy id_first_char+                      cs <-  many (satisfy id_char)+                      return (mkFastString (c:cs)))+++-- construct a foreign export declaration+--+mkExport :: Located CCallConv+         -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs)+         -> P (HsDecl GhcPs)+mkExport (L lc cconv) (L le (StringLiteral esrc entity), v, ty)+ = return $ ForD noExtField $+   ForeignExport { fd_e_ext = noExtField, fd_name = v, fd_sig_ty = ty+                 , fd_fe = CExport (L lc (CExportStatic esrc entity' cconv))+                                   (L le esrc) }+  where+    entity' | nullFS entity = mkExtName (unLoc v)+            | otherwise     = entity++-- Supplying the ext_name in a foreign decl is optional; if it+-- isn't there, the Haskell name is assumed. Note that no transformation+-- of the Haskell name is then performed, so if you foreign export (++),+-- it's external name will be "++". Too bad; it's important because we don't+-- want z-encoding (e.g. names with z's in them shouldn't be doubled)+--+mkExtName :: RdrName -> CLabelString+mkExtName rdrNm = mkFastString (occNameString (rdrNameOcc rdrNm))++--------------------------------------------------------------------------------+-- Help with module system imports/exports++data ImpExpSubSpec = ImpExpAbs+                   | ImpExpAll+                   | ImpExpList [Located ImpExpQcSpec]+                   | ImpExpAllWith [Located ImpExpQcSpec]++data ImpExpQcSpec = ImpExpQcName (Located RdrName)+                  | ImpExpQcType (Located RdrName)+                  | ImpExpQcWildcard++mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs)+mkModuleImpExp (L l specname) subs =+  case subs of+    ImpExpAbs+      | isVarNameSpace (rdrNameSpace name)+                       -> return $ IEVar noExtField (L l (ieNameFromSpec specname))+      | otherwise      -> IEThingAbs noExtField . L l <$> nameT+    ImpExpAll          -> IEThingAll noExtField . L l <$> nameT+    ImpExpList xs      ->+      (\newName -> IEThingWith noExtField (L l newName)+        NoIEWildcard (wrapped xs) []) <$> nameT+    ImpExpAllWith xs                       ->+      do allowed <- getBit PatternSynonymsBit+         if allowed+          then+            let withs = map unLoc xs+                pos   = maybe NoIEWildcard IEWildcard+                          (findIndex isImpExpQcWildcard withs)+                ies   = wrapped $ filter (not . isImpExpQcWildcard . unLoc) xs+            in (\newName+                        -> IEThingWith noExtField (L l newName) pos ies [])+               <$> nameT+          else addFatalError l+            (text "Illegal export form (use PatternSynonyms to enable)")+  where+    name = ieNameVal specname+    nameT =+      if isVarNameSpace (rdrNameSpace name)+        then addFatalError l+              (text "Expecting a type constructor but found a variable,"+               <+> quotes (ppr name) <> text "."+              $$ if isSymOcc $ rdrNameOcc name+                   then text "If" <+> quotes (ppr name)+                        <+> text "is a type constructor"+           <+> text "then enable ExplicitNamespaces and use the 'type' keyword."+                   else empty)+        else return $ ieNameFromSpec specname++    ieNameVal (ImpExpQcName ln)  = unLoc ln+    ieNameVal (ImpExpQcType ln)  = unLoc ln+    ieNameVal (ImpExpQcWildcard) = panic "ieNameVal got wildcard"++    ieNameFromSpec (ImpExpQcName ln)  = IEName ln+    ieNameFromSpec (ImpExpQcType ln)  = IEType ln+    ieNameFromSpec (ImpExpQcWildcard) = panic "ieName got wildcard"++    wrapped = map (mapLoc ieNameFromSpec)++mkTypeImpExp :: Located RdrName   -- TcCls or Var name space+             -> P (Located RdrName)+mkTypeImpExp name =+  do allowed <- getBit ExplicitNamespacesBit+     unless allowed $ addError (getLoc name) $+       text "Illegal keyword 'type' (use ExplicitNamespaces to enable)"+     return (fmap (`setRdrNameSpace` tcClsName) name)++checkImportSpec :: Located [LIE GhcPs] -> P (Located [LIE GhcPs])+checkImportSpec ie@(L _ specs) =+    case [l | (L l (IEThingWith _ _ (IEWildcard _) _ _)) <- specs] of+      [] -> return ie+      (l:_) -> importSpecError l+  where+    importSpecError l =+      addFatalError l+        (text "Illegal import form, this syntax can only be used to bundle"+        $+$ text "pattern synonyms with types in module exports.")++-- In the correct order+mkImpExpSubSpec :: [Located ImpExpQcSpec] -> P ([AddAnn], ImpExpSubSpec)+mkImpExpSubSpec [] = return ([], ImpExpList [])+mkImpExpSubSpec [L _ ImpExpQcWildcard] =+  return ([], ImpExpAll)+mkImpExpSubSpec xs =+  if (any (isImpExpQcWildcard . unLoc) xs)+    then return $ ([], ImpExpAllWith xs)+    else return $ ([], ImpExpList xs)++isImpExpQcWildcard :: ImpExpQcSpec -> Bool+isImpExpQcWildcard ImpExpQcWildcard = True+isImpExpQcWildcard _                = False++-----------------------------------------------------------------------------+-- Warnings and failures++warnPrepositiveQualifiedModule :: SrcSpan -> P ()+warnPrepositiveQualifiedModule span =+  addWarning Opt_WarnPrepositiveQualifiedModule span msg+  where+    msg = text "Found" <+> quotes (text "qualified")+           <+> text "in prepositive position"+       $$ text "Suggested fix: place " <+> quotes (text "qualified")+           <+> text "after the module name instead."++failOpNotEnabledImportQualifiedPost :: SrcSpan -> P ()+failOpNotEnabledImportQualifiedPost loc = addError loc msg+  where+    msg = text "Found" <+> quotes (text "qualified")+          <+> text "in postpositive position. "+      $$ text "To allow this, enable language extension 'ImportQualifiedPost'"++failOpImportQualifiedTwice :: SrcSpan -> P ()+failOpImportQualifiedTwice loc = addError loc msg+  where+    msg = text "Multiple occurrences of 'qualified'"++warnStarIsType :: SrcSpan -> P ()+warnStarIsType span = addWarning Opt_WarnStarIsType span msg+  where+    msg =  text "Using" <+> quotes (text "*")+           <+> text "(or its Unicode variant) to mean"+           <+> quotes (text "Data.Kind.Type")+        $$ text "relies on the StarIsType extension, which will become"+        $$ text "deprecated in the future."+        $$ text "Suggested fix: use" <+> quotes (text "Type")+           <+> text "from" <+> quotes (text "Data.Kind") <+> text "instead."++warnStarBndr :: SrcSpan -> P ()+warnStarBndr span = addWarning Opt_WarnStarBinder span msg+  where+    msg =  text "Found binding occurrence of" <+> quotes (text "*")+           <+> text "yet StarIsType is enabled."+        $$ text "NB. To use (or export) this operator in"+           <+> text "modules with StarIsType,"+        $$ text "    including the definition module, you must qualify it."++failOpFewArgs :: Located RdrName -> P a+failOpFewArgs (L loc op) =+  do { star_is_type <- getBit StarIsTypeBit+     ; let msg = too_few $$ starInfo star_is_type op+     ; addFatalError loc msg }+  where+    too_few = text "Operator applied to too few arguments:" <+> ppr op++failOpDocPrev :: SrcSpan -> P a+failOpDocPrev loc = addFatalError loc msg+  where+    msg = text "Unexpected documentation comment."++-----------------------------------------------------------------------------+-- Misc utils++data PV_Context =+  PV_Context+    { pv_options :: ParserFlags+    , pv_hint :: SDoc  -- See Note [Parser-Validator Hint]+    }++data PV_Accum =+  PV_Accum+    { pv_messages :: DynFlags -> Messages+    , 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++-- See Note [Parser-Validator]+newtype PV a = PV { unPV :: PV_Context -> PV_Accum -> PV_Result a }++instance Functor PV where+  fmap = liftM++instance Applicative PV where+  pure a = a `seq` PV (\_ acc -> PV_Ok acc a)+  (<*>) = ap++instance Monad PV where+  m >>= f = PV $ \ctx acc ->+    case unPV m ctx acc of+      PV_Ok acc' a -> unPV (f a) ctx acc'+      PV_Failed acc' -> PV_Failed acc'++runPV :: PV a -> P a+runPV = runPV_msg empty++runPV_msg :: SDoc -> PV a -> P a+runPV_msg msg m =+  P $ \s ->+    let+      pv_ctx = PV_Context+        { pv_options = options s+        , pv_hint = msg }+      pv_acc = PV_Accum+        { pv_messages = messages s+        , pv_annotations = annotations s+        , pv_comment_q = comment_q s+        , pv_annotations_comments = annotations_comments s }+      mkPState acc' =+        s { messages = pv_messages acc'+          , annotations = pv_annotations acc'+          , comment_q = pv_comment_q acc'+          , annotations_comments = pv_annotations_comments acc' }+    in+      case unPV m pv_ctx pv_acc of+        PV_Ok acc' a -> POk (mkPState acc') a+        PV_Failed acc' -> PFailed (mkPState acc')++localPV_msg :: (SDoc -> SDoc) -> PV a -> PV a+localPV_msg f m =+  let modifyHint ctx = ctx{pv_hint = f (pv_hint ctx)} in+  PV (\ctx acc -> unPV m (modifyHint ctx) acc)++instance MonadP PV where+  addError srcspan msg =+    PV $ \ctx acc@PV_Accum{pv_messages=m} ->+      let msg' = msg $$ pv_hint ctx in+      PV_Ok acc{pv_messages=appendError srcspan msg' m} ()+  addWarning option srcspan warning =+    PV $ \PV_Context{pv_options=o} acc@PV_Accum{pv_messages=m} ->+      PV_Ok acc{pv_messages=appendWarning o option srcspan warning m} ()+  addFatalError srcspan msg =+    addError srcspan msg >> PV (const PV_Failed)+  getBit ext =+    PV $ \ctx acc ->+      let b = ext `xtest` pExtsBitmap (pv_options ctx) in+      PV_Ok acc $! b+  addAnnotation (RealSrcSpan l _) a (RealSrcSpan v _) =+    PV $ \_ acc ->+      let+        (comment_q', new_ann_comments) = allocateComments l (pv_comment_q acc)+        annotations_comments' = new_ann_comments ++ pv_annotations_comments acc+        annotations' = ((l,a), [v]) : pv_annotations acc+        acc' = acc+          { pv_annotations = annotations'+          , pv_comment_q = comment_q'+          , pv_annotations_comments = annotations_comments' }+      in+        PV_Ok acc' ()+  addAnnotation _ _ _ = return ()++{- Note [Parser-Validator]+~~~~~~~~~~~~~~~~~~~~~~~~~~++When resolving ambiguities, we need to postpone failure to make a choice later.+For example, if we have ambiguity between some A and B, our parser could be++  abParser :: P (Maybe A, Maybe B)++This way we can represent four possible outcomes of parsing:++    (Just a, Nothing)       -- definitely A+    (Nothing, Just b)       -- definitely B+    (Just a, Just b)        -- either A or B+    (Nothing, Nothing)      -- neither A nor B++However, if we want to report informative parse errors, accumulate warnings,+and add API annotations, we are better off using 'P' instead of 'Maybe':++  abParser :: P (P A, P B)++So we have an outer layer of P that consumes the input and builds the inner+layer, which validates the input.++For clarity, we introduce the notion of a parser-validator: a parser that does+not consume any input, but may fail or use other effects. Thus we have:++  abParser :: P (PV A, PV B)++-}++{- Note [Parser-Validator Hint]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A PV computation is parametrized by a hint for error messages, which can be set+depending on validation context. We use this in checkPattern to fix #984.++Consider this example, where the user has forgotten a 'do':++  f _ = do+    x <- computation+    case () of+      _ ->+        result <- computation+        case () of () -> undefined++GHC parses it as follows:++  f _ = do+    x <- computation+    (case () of+      _ ->+        result) <- computation+        case () of () -> undefined++Note that this fragment is parsed as a pattern:++  case () of+    _ ->+      result++We attempt to detect such cases and add a hint to the error messages:++  T984.hs:6:9:+    Parse error in pattern: case () of { _ -> result }+    Possibly caused by a missing 'do'?++The "Possibly caused by a missing 'do'?" suggestion is the hint that is passed+as the 'pv_hint' field 'PV_Context'. When validating in a context other than+'bindpat' (a pattern to the left of <-), we set the hint to 'empty' and it has+no effect on the error messages.++-}++-- | Hint about bang patterns, assuming @BangPatterns@ is off.+hintBangPat :: SrcSpan -> Pat GhcPs -> PV ()+hintBangPat span e = do+    bang_on <- getBit BangPatBit+    unless bang_on $+      addError span+        (text "Illegal bang-pattern (use BangPatterns):" $$ ppr e)++data SumOrTuple b+  = Sum ConTag Arity (Located b)+  | Tuple [Located (Maybe (Located b))]++pprSumOrTuple :: Outputable b => Boxity -> SumOrTuple b -> SDoc+pprSumOrTuple boxity = \case+    Sum alt arity e ->+      parOpen <+> ppr_bars (alt - 1) <+> ppr e <+> ppr_bars (arity - alt)+              <+> parClose+    Tuple xs ->+      parOpen <> (fcat . punctuate comma $ map (maybe empty ppr . unLoc) xs)+              <> parClose+  where+    ppr_bars n = hsep (replicate n (Outputable.char '|'))+    (parOpen, parClose) =+      case boxity of+        Boxed -> (text "(", text ")")+        Unboxed -> (text "(#", text "#)")++mkSumOrTupleExpr :: SrcSpan -> Boxity -> SumOrTuple (HsExpr GhcPs) -> PV (LHsExpr GhcPs)++-- Tuple+mkSumOrTupleExpr l boxity (Tuple es) =+    return $ L l (ExplicitTuple noExtField (map toTupArg es) boxity)+  where+    toTupArg :: Located (Maybe (LHsExpr GhcPs)) -> LHsTupArg GhcPs+    toTupArg = mapLoc (maybe missingTupArg (Present noExtField))++-- Sum+mkSumOrTupleExpr l Unboxed (Sum alt arity e) =+    return $ L l (ExplicitSum noExtField alt arity e)+mkSumOrTupleExpr l Boxed a@Sum{} =+    addFatalError l (hang (text "Boxed sums not supported:") 2+                      (pprSumOrTuple Boxed a))++mkSumOrTuplePat :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))++-- Tuple+mkSumOrTuplePat l boxity (Tuple ps) = do+  ps' <- traverse toTupPat ps+  return $ L l (PatBuilderPat (TuplePat noExtField ps' boxity))+  where+    toTupPat :: Located (Maybe (Located (PatBuilder GhcPs))) -> PV (LPat GhcPs)+    toTupPat (L l p) = case p of+      Nothing -> addFatalError l (text "Tuple section in pattern context")+      Just p' -> checkLPat p'++-- Sum+mkSumOrTuplePat l Unboxed (Sum alt arity p) = do+   p' <- checkLPat p+   return $ L l (PatBuilderPat (SumPat noExtField p' alt arity))+mkSumOrTuplePat l Boxed a@Sum{} =+    addFatalError l (hang (text "Boxed sums not supported:") 2+                      (pprSumOrTuple Boxed a))++mkLHsOpTy :: LHsType GhcPs -> Located RdrName -> LHsType GhcPs -> LHsType GhcPs+mkLHsOpTy x op y =+  let loc = getLoc x `combineSrcSpans` getLoc op `combineSrcSpans` getLoc y+  in L loc (mkHsOpTy x op y)++mkLHsDocTy :: LHsType GhcPs -> LHsDocString -> LHsType GhcPs+mkLHsDocTy t doc =+  let loc = getLoc t `combineSrcSpans` getLoc doc+  in L loc (HsDocTy noExtField t doc)++mkLHsDocTyMaybe :: LHsType GhcPs -> Maybe LHsDocString -> LHsType GhcPs+mkLHsDocTyMaybe t = maybe t (mkLHsDocTy t)++-----------------------------------------------------------------------------+-- Token symbols++starSym :: Bool -> String+starSym True = "★"+starSym False = "*"++forallSym :: Bool -> String+forallSym True = "∀"+forallSym False = "forall"
+ compiler/GHC/Parser/PostProcess/Haddock.hs view
@@ -0,0 +1,35 @@+{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++module GHC.Parser.PostProcess.Haddock where++import GHC.Prelude++import GHC.Hs+import GHC.Types.SrcLoc++import Control.Monad++-- -----------------------------------------------------------------------------+-- Adding documentation to record fields (used in parsing).++addFieldDoc :: LConDeclField a -> Maybe LHsDocString -> LConDeclField a+addFieldDoc (L l fld) doc+  = L l (fld { cd_fld_doc = cd_fld_doc fld `mplus` doc })++addFieldDocs :: [LConDeclField a] -> Maybe LHsDocString -> [LConDeclField a]+addFieldDocs [] _ = []+addFieldDocs (x:xs) doc = addFieldDoc x doc : xs+++addConDoc :: LConDecl a -> Maybe LHsDocString -> LConDecl a+addConDoc decl    Nothing = decl+addConDoc (L p c) doc     = L p ( c { con_doc = con_doc c `mplus` doc } )++addConDocs :: [LConDecl a] -> Maybe LHsDocString -> [LConDecl a]+addConDocs [] _ = []+addConDocs [x] doc = [addConDoc x doc]+addConDocs (x:xs) doc = x : addConDocs xs doc++addConDocFirst :: [LConDecl a] -> Maybe LHsDocString -> [LConDecl a]+addConDocFirst [] _ = []+addConDocFirst (x:xs) doc = addConDoc x doc : xs
compiler/GHC/Platform/ARM.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.ARM where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_arm 1
compiler/GHC/Platform/ARM64.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.ARM64 where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_aarch64 1
compiler/GHC/Platform/NoRegs.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.NoRegs where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 1 #include "../../../includes/CodeGen.Platform.hs"
compiler/GHC/Platform/PPC.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.PPC where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_powerpc 1
compiler/GHC/Platform/Reg.hs view
@@ -26,9 +26,9 @@  where -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique import GHC.Platform.Reg.Class import Data.List (intersect)
compiler/GHC/Platform/Reg/Class.hs view
@@ -4,9 +4,9 @@  where -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable as Outputable import GHC.Types.Unique
compiler/GHC/Platform/Regs.hs view
@@ -3,7 +3,7 @@        (callerSaves, activeStgRegs, haveRegBase, globalRegMaybe, freeReg)        where -import GhcPrelude+import GHC.Prelude  import GHC.Cmm.Expr import GHC.Platform
compiler/GHC/Platform/S390X.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.S390X where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_s390x 1
compiler/GHC/Platform/SPARC.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.SPARC where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_sparc 1
compiler/GHC/Platform/X86.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.X86 where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_i386 1
compiler/GHC/Platform/X86_64.hs view
@@ -2,7 +2,7 @@  module GHC.Platform.X86_64 where -import GhcPrelude+import GHC.Prelude  #define MACHREGS_NO_REGS 0 #define MACHREGS_x86_64 1
+ compiler/GHC/Prelude.hs view
@@ -0,0 +1,33 @@+{-# LANGUAGE CPP #-}++-- | Custom GHC "Prelude"+--+-- This module serves as a replacement for the "Prelude" module+-- and abstracts over differences between the bootstrapping+-- GHC version, and may also provide a common default vocabulary.++-- Every module in GHC+--   * Is compiled with -XNoImplicitPrelude+--   * Explicitly imports GHC.Prelude++module GHC.Prelude (module X) where++-- We export the 'Semigroup' class but w/o the (<>) operator to avoid+-- clashing with the (Outputable.<>) operator which is heavily used+-- through GHC's code-base.++import Prelude as X hiding ((<>))+import Data.Foldable as X (foldl')++{-+Note [Why do we import Prelude here?]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The files ghc-boot-th.cabal, ghc-boot.cabal, ghci.cabal and+ghc-heap.cabal contain the directive default-extensions:+NoImplicitPrelude. There are two motivations for this:+  - Consistency with the compiler directory, which enables+    NoImplicitPrelude;+  - Allows loading the above dependent packages with ghc-in-ghci,+    giving a smoother development experience when adding new+    extensions.+-}
compiler/GHC/Runtime/Eval/Types.hs view
@@ -12,17 +12,17 @@         BreakInfo(..)         ) where -import GhcPrelude+import GHC.Prelude  import GHCi.RemoteTypes import GHCi.Message (EvalExpr, ResumeContext) import GHC.Types.Id import GHC.Types.Name-import GHC.Types.Module+import GHC.Unit.Module import GHC.Types.Name.Reader import GHC.Core.Type import GHC.Types.SrcLoc-import Exception+import GHC.Utils.Exception  import Data.Word import GHC.Stack.CCS
compiler/GHC/Runtime/Heap/Layout.hs view
@@ -44,13 +44,13 @@         card, cardRoundUp, cardTableSizeB, cardTableSizeW     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Basic( ConTagZ ) import GHC.Driver.Session-import Outputable+import GHC.Utils.Outputable import GHC.Platform-import FastString+import GHC.Data.FastString  import Data.Word import Data.Bits
compiler/GHC/Runtime/Interpreter/Types.hs view
@@ -10,7 +10,7 @@    ) where -import GhcPrelude+import GHC.Prelude  import GHCi.RemoteTypes import GHCi.Message         ( Pipe )
compiler/GHC/Runtime/Linker/Types.hs view
@@ -15,13 +15,13 @@       SptEntry(..)     ) where -import GhcPrelude              ( FilePath, String, show )+import GHC.Prelude             ( FilePath, String, show ) import Data.Time               ( UTCTime ) import Data.Maybe              ( Maybe ) import Control.Concurrent.MVar ( MVar )-import GHC.Types.Module        ( InstalledUnitId, Module )+import GHC.Unit                ( UnitId, Module ) import GHC.ByteCode.Types      ( ItblEnv, CompiledByteCode )-import Outputable+import GHC.Utils.Outputable import GHC.Types.Var           ( Id ) import GHC.Fingerprint.Type    ( Fingerprint ) import GHC.Types.Name.Env      ( NameEnv )@@ -62,7 +62,7 @@        temp_sos :: ![(FilePath, String)] }  -- TODO: Make this type more precise-type LinkerUnitId = InstalledUnitId+type LinkerUnitId = UnitId  -- | Information we can use to dynamically link modules into the compiler data Linkable = LM {@@ -95,7 +95,7 @@                        -- carries some static pointer table entries which                        -- should be loaded along with the BCOs.                        -- See Note [Grant plan for static forms] in-                       -- StaticPtrTable.+                       -- GHC.Iface.Tidy.StaticPtrTable.  instance Outputable Unlinked where   ppr (DotO path)   = text "DotO" <+> text path@@ -104,7 +104,7 @@   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.+-- See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable. data SptEntry = SptEntry Id Fingerprint  instance Outputable SptEntry where
+ compiler/GHC/Settings.hs view
@@ -0,0 +1,289 @@+{-# LANGUAGE CPP #-}++-- | Run-time settings+module GHC.Settings+  ( Settings (..)+  , ToolSettings (..)+  , FileSettings (..)+  , GhcNameVersion (..)+  , PlatformConstants (..)+  , Platform (..)+  , PlatformMisc (..)+  , PlatformMini (..)+  -- * Accessors+  , 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+  ) where++import GHC.Prelude++import GHC.Utils.CliOption+import GHC.Utils.Fingerprint+import GHC.Platform++data Settings = Settings+  { sGhcNameVersion    :: {-# UNPACk #-} !GhcNameVersion+  , sFileSettings      :: {-# UNPACK #-} !FileSettings+  , sTargetPlatform    :: Platform       -- Filled in by SysTools+  , sToolSettings      :: {-# UNPACK #-} !ToolSettings+  , sPlatformMisc      :: {-# UNPACK #-} !PlatformMisc+  , sPlatformConstants :: PlatformConstants++  -- You shouldn't need to look things up in rawSettings directly.+  -- They should have their own fields instead.+  , sRawSettings       :: [(String, String)]+  }++-- | Settings for other executables GHC calls.+--+-- Probably should further split down by phase, or split between+-- platform-specific and platform-agnostic.+data ToolSettings = ToolSettings+  { toolSettings_ldSupportsCompactUnwind :: Bool+  , toolSettings_ldSupportsBuildId       :: Bool+  , toolSettings_ldSupportsFilelist      :: Bool+  , toolSettings_ldIsGnuLd               :: Bool+  , toolSettings_ccSupportsNoPie         :: Bool++  -- commands for particular phases+  , toolSettings_pgm_L       :: String+  , toolSettings_pgm_P       :: (String, [Option])+  , toolSettings_pgm_F       :: String+  , toolSettings_pgm_c       :: String+  , toolSettings_pgm_a       :: (String, [Option])+  , toolSettings_pgm_l       :: (String, [Option])+  , toolSettings_pgm_dll     :: (String, [Option])+  , toolSettings_pgm_T       :: String+  , toolSettings_pgm_windres :: String+  , toolSettings_pgm_libtool :: String+  , toolSettings_pgm_ar      :: String+  , toolSettings_pgm_ranlib  :: String+  , -- | LLVM: opt llvm optimiser+    toolSettings_pgm_lo      :: (String, [Option])+  , -- | LLVM: llc static compiler+    toolSettings_pgm_lc      :: (String, [Option])+  , -- | LLVM: c compiler+    toolSettings_pgm_lcc     :: (String, [Option])+  , toolSettings_pgm_i       :: String++  -- options for particular phases+  , toolSettings_opt_L             :: [String]+  , toolSettings_opt_P             :: [String]+  , -- | cached Fingerprint of sOpt_P+    -- See Note [Repeated -optP hashing]+    toolSettings_opt_P_fingerprint :: Fingerprint+  , toolSettings_opt_F             :: [String]+  , toolSettings_opt_c             :: [String]+  , toolSettings_opt_cxx           :: [String]+  , toolSettings_opt_a             :: [String]+  , toolSettings_opt_l             :: [String]+  , toolSettings_opt_windres       :: [String]+  , -- | LLVM: llvm optimiser+    toolSettings_opt_lo            :: [String]+  , -- | LLVM: llc static compiler+    toolSettings_opt_lc            :: [String]+  , -- | LLVM: c compiler+    toolSettings_opt_lcc           :: [String]+  , -- | iserv options+    toolSettings_opt_i             :: [String]++  , toolSettings_extraGccViaCFlags :: [String]+  }+++-- | Paths to various files and directories used by GHC, including those that+-- provide more settings.+data FileSettings = FileSettings+  { fileSettings_ghcUsagePath          :: FilePath       -- ditto+  , fileSettings_ghciUsagePath         :: FilePath       -- ditto+  , fileSettings_toolDir               :: Maybe FilePath -- ditto+  , fileSettings_topDir                :: FilePath       -- ditto+  , fileSettings_tmpDir                :: String      -- no trailing '/'+  , fileSettings_globalPackageDatabase :: FilePath+  }+++-- | Settings for what GHC this is.+data GhcNameVersion = GhcNameVersion+  { ghcNameVersion_programName    :: String+  , ghcNameVersion_projectVersion :: String+  }++-- Produced by deriveConstants+-- Provides PlatformConstants datatype+#include "GHCConstantsHaskellType.hs"++-----------------------------------------------------------------------------+-- Accessessors from 'Settings'++sProgramName         :: Settings -> String+sProgramName = ghcNameVersion_programName . sGhcNameVersion+sProjectVersion      :: Settings -> String+sProjectVersion = ghcNameVersion_projectVersion . sGhcNameVersion++sGhcUsagePath        :: Settings -> FilePath+sGhcUsagePath = fileSettings_ghcUsagePath . sFileSettings+sGhciUsagePath       :: Settings -> FilePath+sGhciUsagePath = fileSettings_ghciUsagePath . sFileSettings+sToolDir             :: Settings -> Maybe FilePath+sToolDir = fileSettings_toolDir . sFileSettings+sTopDir              :: Settings -> FilePath+sTopDir = fileSettings_topDir . sFileSettings+sTmpDir              :: Settings -> String+sTmpDir = fileSettings_tmpDir . sFileSettings+sGlobalPackageDatabasePath :: Settings -> FilePath+sGlobalPackageDatabasePath = fileSettings_globalPackageDatabase . sFileSettings++sLdSupportsCompactUnwind :: Settings -> Bool+sLdSupportsCompactUnwind = toolSettings_ldSupportsCompactUnwind . sToolSettings+sLdSupportsBuildId :: Settings -> Bool+sLdSupportsBuildId = toolSettings_ldSupportsBuildId . sToolSettings+sLdSupportsFilelist :: Settings -> Bool+sLdSupportsFilelist = toolSettings_ldSupportsFilelist . sToolSettings+sLdIsGnuLd :: Settings -> Bool+sLdIsGnuLd = toolSettings_ldIsGnuLd . sToolSettings+sGccSupportsNoPie :: Settings -> Bool+sGccSupportsNoPie = toolSettings_ccSupportsNoPie . sToolSettings++sPgm_L :: Settings -> String+sPgm_L = toolSettings_pgm_L . sToolSettings+sPgm_P :: Settings -> (String, [Option])+sPgm_P = toolSettings_pgm_P . sToolSettings+sPgm_F :: Settings -> String+sPgm_F = toolSettings_pgm_F . sToolSettings+sPgm_c :: Settings -> String+sPgm_c = toolSettings_pgm_c . sToolSettings+sPgm_a :: Settings -> (String, [Option])+sPgm_a = toolSettings_pgm_a . sToolSettings+sPgm_l :: Settings -> (String, [Option])+sPgm_l = toolSettings_pgm_l . sToolSettings+sPgm_dll :: Settings -> (String, [Option])+sPgm_dll = toolSettings_pgm_dll . sToolSettings+sPgm_T :: Settings -> String+sPgm_T = toolSettings_pgm_T . sToolSettings+sPgm_windres :: Settings -> String+sPgm_windres = toolSettings_pgm_windres . sToolSettings+sPgm_libtool :: Settings -> String+sPgm_libtool = toolSettings_pgm_libtool . sToolSettings+sPgm_ar :: Settings -> String+sPgm_ar = toolSettings_pgm_ar . sToolSettings+sPgm_ranlib :: Settings -> String+sPgm_ranlib = toolSettings_pgm_ranlib . sToolSettings+sPgm_lo :: Settings -> (String, [Option])+sPgm_lo = toolSettings_pgm_lo . sToolSettings+sPgm_lc :: Settings -> (String, [Option])+sPgm_lc = toolSettings_pgm_lc . sToolSettings+sPgm_lcc :: Settings -> (String, [Option])+sPgm_lcc = toolSettings_pgm_lcc . sToolSettings+sPgm_i :: Settings -> String+sPgm_i = toolSettings_pgm_i . sToolSettings+sOpt_L :: Settings -> [String]+sOpt_L = toolSettings_opt_L . sToolSettings+sOpt_P :: Settings -> [String]+sOpt_P = toolSettings_opt_P . sToolSettings+sOpt_P_fingerprint :: Settings -> Fingerprint+sOpt_P_fingerprint = toolSettings_opt_P_fingerprint . sToolSettings+sOpt_F :: Settings -> [String]+sOpt_F = toolSettings_opt_F . sToolSettings+sOpt_c :: Settings -> [String]+sOpt_c = toolSettings_opt_c . sToolSettings+sOpt_cxx :: Settings -> [String]+sOpt_cxx = toolSettings_opt_cxx . sToolSettings+sOpt_a :: Settings -> [String]+sOpt_a = toolSettings_opt_a . sToolSettings+sOpt_l :: Settings -> [String]+sOpt_l = toolSettings_opt_l . sToolSettings+sOpt_windres :: Settings -> [String]+sOpt_windres = toolSettings_opt_windres . sToolSettings+sOpt_lo :: Settings -> [String]+sOpt_lo = toolSettings_opt_lo . sToolSettings+sOpt_lc :: Settings -> [String]+sOpt_lc = toolSettings_opt_lc . sToolSettings+sOpt_lcc :: Settings -> [String]+sOpt_lcc = toolSettings_opt_lcc . sToolSettings+sOpt_i :: Settings -> [String]+sOpt_i = toolSettings_opt_i . sToolSettings++sExtraGccViaCFlags :: Settings -> [String]+sExtraGccViaCFlags = toolSettings_extraGccViaCFlags . sToolSettings++sTargetPlatformString :: Settings -> String+sTargetPlatformString = platformMisc_targetPlatformString . sPlatformMisc+sIntegerLibrary :: Settings -> String+sIntegerLibrary = platformMisc_integerLibrary . sPlatformMisc+sIntegerLibraryType :: Settings -> IntegerLibrary+sIntegerLibraryType = platformMisc_integerLibraryType . sPlatformMisc+sGhcWithInterpreter :: Settings -> Bool+sGhcWithInterpreter = platformMisc_ghcWithInterpreter . sPlatformMisc+sGhcWithNativeCodeGen :: Settings -> Bool+sGhcWithNativeCodeGen = platformMisc_ghcWithNativeCodeGen . sPlatformMisc+sGhcWithSMP :: Settings -> Bool+sGhcWithSMP = platformMisc_ghcWithSMP . sPlatformMisc+sGhcRTSWays :: Settings -> String+sGhcRTSWays = platformMisc_ghcRTSWays . sPlatformMisc+sTablesNextToCode :: Settings -> Bool+sTablesNextToCode = platformMisc_tablesNextToCode . sPlatformMisc+sLeadingUnderscore :: Settings -> Bool+sLeadingUnderscore = platformMisc_leadingUnderscore . sPlatformMisc+sLibFFI :: Settings -> Bool+sLibFFI = platformMisc_libFFI . sPlatformMisc+sGhcThreaded :: Settings -> Bool+sGhcThreaded = platformMisc_ghcThreaded . sPlatformMisc+sGhcDebugged :: Settings -> Bool+sGhcDebugged = platformMisc_ghcDebugged . sPlatformMisc+sGhcRtsWithLibdw :: Settings -> Bool+sGhcRtsWithLibdw = platformMisc_ghcRtsWithLibdw . sPlatformMisc
+ compiler/GHC/Settings/Constants.hs view
@@ -0,0 +1,45 @@+-- | Compile-time settings+module GHC.Settings.Constants where++import GHC.Prelude++import Config++hiVersion :: Integer+hiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Integer++-- All pretty arbitrary:++mAX_TUPLE_SIZE :: Int+mAX_TUPLE_SIZE = 62 -- Should really match the number+                    -- of decls in Data.Tuple++mAX_CTUPLE_SIZE :: Int   -- Constraint tuples+mAX_CTUPLE_SIZE = 62     -- Should match the number of decls in GHC.Classes++mAX_SUM_SIZE :: Int+mAX_SUM_SIZE = 62++-- | Default maximum depth for both class instance search and type family+-- reduction. See also #5395.+mAX_REDUCTION_DEPTH :: Int+mAX_REDUCTION_DEPTH = 200++-- | Default maximum constraint-solver iterations+-- Typically there should be very few+mAX_SOLVER_ITERATIONS :: Int+mAX_SOLVER_ITERATIONS = 4++wORD64_SIZE :: Int+wORD64_SIZE = 8++-- Size of float in bytes.+fLOAT_SIZE :: Int+fLOAT_SIZE = 4++-- Size of double in bytes.+dOUBLE_SIZE :: Int+dOUBLE_SIZE = 8++tARGET_MAX_CHAR :: Int+tARGET_MAX_CHAR = 0x10ffff
compiler/GHC/Stg/Syntax.hs view
@@ -61,7 +61,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Core     ( AltCon, Tickish ) import GHC.Types.CostCentre ( CostCentreStack )@@ -74,16 +74,16 @@ import GHC.Types.Id import GHC.Types.Var.Set import GHC.Types.Literal     ( Literal, literalType )-import GHC.Types.Module      ( Module )-import Outputable-import GHC.Driver.Packages ( isDynLinkName )+import GHC.Unit.Module       ( Module )+import GHC.Utils.Outputable+import GHC.Unit.State        ( isDynLinkName ) import GHC.Platform import GHC.Core.Ppr( {- instances -} )-import PrimOp            ( PrimOp, PrimCall )+import GHC.Builtin.PrimOps ( PrimOp, PrimCall ) import GHC.Core.TyCon    ( PrimRep(..), TyCon ) import GHC.Core.Type     ( Type ) import GHC.Types.RepType ( typePrimRep1 )-import Util+import GHC.Utils.Misc  import Data.List.NonEmpty ( NonEmpty, toList ) @@ -126,15 +126,17 @@ -- If so, we can't allocate it statically isDllConApp :: DynFlags -> Module -> DataCon -> [StgArg] -> Bool isDllConApp dflags this_mod con args- | platformOS (targetPlatform dflags) == OSMinGW32-    = isDynLinkName dflags this_mod (dataConName con) || any is_dll_arg args+ | not (gopt Opt_ExternalDynamicRefs dflags) = False+ | platformOS platform == OSMinGW32+    = isDynLinkName platform this_mod (dataConName con) || any is_dll_arg args  | otherwise = False   where+    platform = targetPlatform dflags     -- NB: typePrimRep1 is legit because any free variables won't have     -- unlifted type (there are no unlifted things at top level)     is_dll_arg :: StgArg -> Bool     is_dll_arg (StgVarArg v) =  isAddrRep (typePrimRep1 (idType v))-                             && isDynLinkName dflags this_mod (idName v)+                             && isDynLinkName platform this_mod (idName v)     is_dll_arg _             = False  -- True of machine addresses; these are the things that don't work across DLLs.
+ compiler/GHC/SysTools/BaseDir.hs view
@@ -0,0 +1,137 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-}++{-+-----------------------------------------------------------------------------+--+-- (c) The University of Glasgow 2001-2017+--+-- Finding the compiler's base directory.+--+-----------------------------------------------------------------------------+-}++module GHC.SysTools.BaseDir+  ( expandTopDir, expandToolDir+  , findTopDir, findToolDir+  , tryFindTopDir+  ) where++#include "HsVersions.h"++import GHC.Prelude++-- See note [Base Dir] for why some of this logic is shared with ghc-pkg.+import GHC.BaseDir++import GHC.Utils.Panic++import System.Environment (lookupEnv)+import System.FilePath++-- Windows+#if defined(mingw32_HOST_OS)+import System.Directory (doesDirectoryExist)+#endif++#if defined(mingw32_HOST_OS)+# if defined(i386_HOST_ARCH)+#  define WINDOWS_CCONV stdcall+# elif defined(x86_64_HOST_ARCH)+#  define WINDOWS_CCONV ccall+# else+#  error Unknown mingw32 arch+# endif+#endif++{-+Note [topdir: How GHC finds its files]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++GHC needs various support files (library packages, RTS etc), plus+various auxiliary programs (cp, gcc, etc).  It starts by finding topdir,+the root of GHC's support files++On Unix:+  - ghc always has a shell wrapper that passes a -B<dir> option++On Windows:+  - ghc never has a shell wrapper.+  - we can find the location of the ghc binary, which is+        $topdir/<foo>/<something>.exe+    where <something> may be "ghc", "ghc-stage2", or similar+  - we strip off the "<foo>/<something>.exe" to leave $topdir.++from topdir we can find package.conf, ghc-asm, etc.+++Note [tooldir: How GHC finds mingw on Windows]++GHC has some custom logic on Windows for finding the mingw+toolchain and perl. Depending on whether GHC is built+with the make build system or Hadrian, and on whether we're+running a bindist, we might find the mingw toolchain and perl+either under $topdir/../{mingw, perl}/ or+$topdir/../../{mingw, perl}/.++-}++-- | Expand occurrences of the @$tooldir@ interpolation in a string+-- on Windows, leave the string untouched otherwise.+expandToolDir :: Maybe FilePath -> String -> String+#if defined(mingw32_HOST_OS)+expandToolDir (Just tool_dir) s = expandPathVar "tooldir" tool_dir s+expandToolDir Nothing         _ = panic "Could not determine $tooldir"+#else+expandToolDir _ s = s+#endif++-- | Returns a Unix-format path pointing to TopDir.+findTopDir :: Maybe String -- Maybe TopDir path (without the '-B' prefix).+           -> IO String    -- TopDir (in Unix format '/' separated)+findTopDir m_minusb = do+  maybe_exec_dir <- tryFindTopDir m_minusb+  case maybe_exec_dir of+      -- "Just" on Windows, "Nothing" on unix+      Nothing -> throwGhcExceptionIO $+          InstallationError "missing -B<dir> option"+      Just dir -> return dir++tryFindTopDir+  :: Maybe String -- ^ Maybe TopDir path (without the '-B' prefix).+  -> IO (Maybe String) -- ^ TopDir (in Unix format '/' separated)+tryFindTopDir (Just minusb) = return $ Just $ normalise minusb+tryFindTopDir Nothing+    = do -- The _GHC_TOP_DIR environment variable can be used to specify+         -- the top dir when the -B argument is not specified. It is not+         -- intended for use by users, it was added specifically for the+         -- purpose of running GHC within GHCi.+         maybe_env_top_dir <- lookupEnv "_GHC_TOP_DIR"+         case maybe_env_top_dir of+             Just env_top_dir -> return $ Just env_top_dir+             -- Try directory of executable+             Nothing -> getBaseDir+++-- See Note [tooldir: How GHC finds mingw and perl on Windows]+-- Returns @Nothing@ when not on Windows.+-- When called on Windows, it either throws an error when the+-- tooldir can't be located, or returns @Just tooldirpath@.+findToolDir+  :: FilePath -- ^ topdir+  -> IO (Maybe FilePath)+#if defined(mingw32_HOST_OS)+findToolDir top_dir = go 0 (top_dir </> "..")+  where maxDepth = 3+        go :: Int -> FilePath -> IO (Maybe FilePath)+        go k path+          | k == maxDepth = throwGhcExceptionIO $+              InstallationError "could not detect mingw toolchain"+          | otherwise = do+              oneLevel <- doesDirectoryExist (path </> "mingw")+              if oneLevel+                then return (Just path)+                else go (k+1) (path </> "..")+#else+findToolDir _ = return Nothing+#endif
+ compiler/GHC/SysTools/FileCleanup.hs view
@@ -0,0 +1,314 @@+{-# LANGUAGE CPP #-}+module GHC.SysTools.FileCleanup+  ( TempFileLifetime(..)+  , cleanTempDirs, cleanTempFiles, cleanCurrentModuleTempFiles+  , addFilesToClean, changeTempFilesLifetime+  , newTempName, newTempLibName, newTempDir+  , withSystemTempDirectory, withTempDirectory+  ) where++import GHC.Prelude++import GHC.Driver.Session+import GHC.Utils.Error+import GHC.Utils.Outputable+import GHC.Utils.Misc+import GHC.Utils.Exception as Exception+import GHC.Driver.Phases++import Control.Monad+import Data.List+import qualified Data.Set as Set+import qualified Data.Map as Map+import Data.IORef+import System.Directory+import System.FilePath+import System.IO.Error++#if !defined(mingw32_HOST_OS)+import qualified System.Posix.Internals+#endif++-- | Used when a temp file is created. This determines which component Set of+-- FilesToClean will get the temp file+data TempFileLifetime+  = TFL_CurrentModule+  -- ^ A file with lifetime TFL_CurrentModule will be cleaned up at the+  -- end of upweep_mod+  | TFL_GhcSession+  -- ^ A file with lifetime TFL_GhcSession will be cleaned up at the end of+  -- runGhc(T)+  deriving (Show)++cleanTempDirs :: DynFlags -> IO ()+cleanTempDirs dflags+   = unless (gopt Opt_KeepTmpFiles dflags)+   $ mask_+   $ do let ref = dirsToClean dflags+        ds <- atomicModifyIORef' ref $ \ds -> (Map.empty, ds)+        removeTmpDirs dflags (Map.elems ds)++-- | Delete all files in @filesToClean dflags@.+cleanTempFiles :: DynFlags -> IO ()+cleanTempFiles dflags+   = unless (gopt Opt_KeepTmpFiles dflags)+   $ mask_+   $ do let ref = filesToClean dflags+        to_delete <- atomicModifyIORef' ref $+            \FilesToClean+                { ftcCurrentModule = cm_files+                , ftcGhcSession = gs_files+                } -> ( emptyFilesToClean+                     , Set.toList cm_files ++ Set.toList gs_files)+        removeTmpFiles dflags to_delete++-- | Delete all files in @filesToClean dflags@. That have lifetime+-- TFL_CurrentModule.+-- If a file must be cleaned eventually, but must survive a+-- cleanCurrentModuleTempFiles, ensure it has lifetime TFL_GhcSession.+cleanCurrentModuleTempFiles :: DynFlags -> IO ()+cleanCurrentModuleTempFiles dflags+   = unless (gopt Opt_KeepTmpFiles dflags)+   $ mask_+   $ do let ref = filesToClean dflags+        to_delete <- atomicModifyIORef' ref $+            \ftc@FilesToClean{ftcCurrentModule = cm_files} ->+                (ftc {ftcCurrentModule = Set.empty}, Set.toList cm_files)+        removeTmpFiles dflags to_delete++-- | Ensure that new_files are cleaned on the next call of+-- 'cleanTempFiles' or 'cleanCurrentModuleTempFiles', depending on lifetime.+-- If any of new_files are already tracked, they will have their lifetime+-- updated.+addFilesToClean :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()+addFilesToClean dflags lifetime new_files = modifyIORef' (filesToClean dflags) $+  \FilesToClean+    { ftcCurrentModule = cm_files+    , ftcGhcSession = gs_files+    } -> case lifetime of+      TFL_CurrentModule -> FilesToClean+        { ftcCurrentModule = cm_files `Set.union` new_files_set+        , ftcGhcSession = gs_files `Set.difference` new_files_set+        }+      TFL_GhcSession -> FilesToClean+        { ftcCurrentModule = cm_files `Set.difference` new_files_set+        , ftcGhcSession = gs_files `Set.union` new_files_set+        }+  where+    new_files_set = Set.fromList new_files++-- | Update the lifetime of files already being tracked. If any files are+-- not being tracked they will be discarded.+changeTempFilesLifetime :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()+changeTempFilesLifetime dflags lifetime files = do+  FilesToClean+    { ftcCurrentModule = cm_files+    , ftcGhcSession = gs_files+    } <- readIORef (filesToClean dflags)+  let old_set = case lifetime of+        TFL_CurrentModule -> gs_files+        TFL_GhcSession -> cm_files+      existing_files = [f | f <- files, f `Set.member` old_set]+  addFilesToClean dflags lifetime existing_files++-- Return a unique numeric temp file suffix+newTempSuffix :: DynFlags -> IO Int+newTempSuffix dflags =+  atomicModifyIORef' (nextTempSuffix dflags) $ \n -> (n+1,n)++-- Find a temporary name that doesn't already exist.+newTempName :: DynFlags -> TempFileLifetime -> Suffix -> IO FilePath+newTempName dflags lifetime extn+  = do d <- getTempDir dflags+       findTempName (d </> "ghc_") -- See Note [Deterministic base name]+  where+    findTempName :: FilePath -> IO FilePath+    findTempName prefix+      = do n <- newTempSuffix dflags+           let filename = prefix ++ show n <.> extn+           b <- doesFileExist filename+           if b then findTempName prefix+                else do -- clean it up later+                        addFilesToClean dflags lifetime [filename]+                        return filename++newTempDir :: DynFlags -> IO FilePath+newTempDir dflags+  = do d <- getTempDir dflags+       findTempDir (d </> "ghc_")+  where+    findTempDir :: FilePath -> IO FilePath+    findTempDir prefix+      = do n <- newTempSuffix dflags+           let filename = prefix ++ show n+           b <- doesDirectoryExist filename+           if b then findTempDir prefix+                else do createDirectory filename+                        -- see mkTempDir below; this is wrong: -> consIORef (dirsToClean dflags) filename+                        return filename++newTempLibName :: DynFlags -> TempFileLifetime -> Suffix+  -> IO (FilePath, FilePath, String)+newTempLibName dflags lifetime extn+  = do d <- getTempDir dflags+       findTempName d ("ghc_")+  where+    findTempName :: FilePath -> String -> IO (FilePath, FilePath, String)+    findTempName dir prefix+      = do n <- newTempSuffix dflags -- See Note [Deterministic base name]+           let libname = prefix ++ show n+               filename = dir </> "lib" ++ libname <.> extn+           b <- doesFileExist filename+           if b then findTempName dir prefix+                else do -- clean it up later+                        addFilesToClean dflags lifetime [filename]+                        return (filename, dir, libname)+++-- Return our temporary directory within tmp_dir, creating one if we+-- don't have one yet.+getTempDir :: DynFlags -> IO FilePath+getTempDir dflags = do+    mapping <- readIORef dir_ref+    case Map.lookup tmp_dir mapping of+        Nothing -> do+            pid <- getProcessID+            let prefix = tmp_dir </> "ghc" ++ show pid ++ "_"+            mask_ $ mkTempDir prefix+        Just dir -> return dir+  where+    tmp_dir = tmpDir dflags+    dir_ref = dirsToClean dflags++    mkTempDir :: FilePath -> IO FilePath+    mkTempDir prefix = do+        n <- newTempSuffix dflags+        let our_dir = prefix ++ show n++        -- 1. Speculatively create our new directory.+        createDirectory our_dir++        -- 2. Update the dirsToClean mapping unless an entry already exists+        -- (i.e. unless another thread beat us to it).+        their_dir <- atomicModifyIORef' dir_ref $ \mapping ->+            case Map.lookup tmp_dir mapping of+                Just dir -> (mapping, Just dir)+                Nothing  -> (Map.insert tmp_dir our_dir mapping, Nothing)++        -- 3. If there was an existing entry, return it and delete the+        -- directory we created.  Otherwise return the directory we created.+        case their_dir of+            Nothing  -> do+                debugTraceMsg dflags 2 $+                    text "Created temporary directory:" <+> text our_dir+                return our_dir+            Just dir -> do+                removeDirectory our_dir+                return dir+      `catchIO` \e -> if isAlreadyExistsError e+                      then mkTempDir prefix else ioError e++{- Note [Deterministic base name]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++The filename of temporary files, especially the basename of C files, can end+up in the output in some form, e.g. as part of linker debug information. In the+interest of bit-wise exactly reproducible compilation (#4012), the basename of+the temporary file no longer contains random information (it used to contain+the process id).++This is ok, as the temporary directory used contains the pid (see getTempDir).+-}+removeTmpDirs :: DynFlags -> [FilePath] -> IO ()+removeTmpDirs dflags ds+  = traceCmd dflags "Deleting temp dirs"+             ("Deleting: " ++ unwords ds)+             (mapM_ (removeWith dflags removeDirectory) ds)++removeTmpFiles :: DynFlags -> [FilePath] -> IO ()+removeTmpFiles dflags fs+  = warnNon $+    traceCmd dflags "Deleting temp files"+             ("Deleting: " ++ unwords deletees)+             (mapM_ (removeWith dflags removeFile) deletees)+  where+     -- Flat out refuse to delete files that are likely to be source input+     -- files (is there a worse bug than having a compiler delete your source+     -- files?)+     --+     -- Deleting source files is a sign of a bug elsewhere, so prominently flag+     -- the condition.+    warnNon act+     | null non_deletees = act+     | otherwise         = do+        putMsg dflags (text "WARNING - NOT deleting source files:"+                       <+> hsep (map text non_deletees))+        act++    (non_deletees, deletees) = partition isHaskellUserSrcFilename fs++removeWith :: DynFlags -> (FilePath -> IO ()) -> FilePath -> IO ()+removeWith dflags remover f = remover f `catchIO`+  (\e ->+   let msg = if isDoesNotExistError e+             then text "Warning: deleting non-existent" <+> text f+             else text "Warning: exception raised when deleting"+                                            <+> text f <> colon+               $$ text (show e)+   in debugTraceMsg dflags 2 msg+  )++#if defined(mingw32_HOST_OS)+-- relies on Int == Int32 on Windows+foreign import ccall unsafe "_getpid" getProcessID :: IO Int+#else+getProcessID :: IO Int+getProcessID = System.Posix.Internals.c_getpid >>= return . fromIntegral+#endif++-- The following three functions are from the `temporary` package.++-- | Create and use a temporary directory in the system standard temporary+-- directory.+--+-- Behaves exactly the same as 'withTempDirectory', except that the parent+-- temporary directory will be that returned by 'getTemporaryDirectory'.+withSystemTempDirectory :: String   -- ^ Directory name template. See 'openTempFile'.+                        -> (FilePath -> IO a) -- ^ Callback that can use the directory+                        -> IO a+withSystemTempDirectory template action =+  getTemporaryDirectory >>= \tmpDir -> withTempDirectory tmpDir template action+++-- | Create and use a temporary directory.+--+-- Creates a new temporary directory inside the given directory, making use+-- of the template. The temp directory is deleted after use. For example:+--+-- > withTempDirectory "src" "sdist." $ \tmpDir -> do ...+--+-- The @tmpDir@ will be a new subdirectory of the given directory, e.g.+-- @src/sdist.342@.+withTempDirectory :: FilePath -- ^ Temp directory to create the directory in+                  -> String   -- ^ Directory name template. See 'openTempFile'.+                  -> (FilePath -> IO a) -- ^ Callback that can use the directory+                  -> IO a+withTempDirectory targetDir template =+  Exception.bracket+    (createTempDirectory targetDir template)+    (ignoringIOErrors . removeDirectoryRecursive)++ignoringIOErrors :: IO () -> IO ()+ignoringIOErrors ioe = ioe `catch` (\e -> const (return ()) (e :: IOError))+++createTempDirectory :: FilePath -> String -> IO FilePath+createTempDirectory dir template = do+  pid <- getProcessID+  findTempName pid+  where findTempName x = do+            let path = dir </> template ++ show x+            createDirectory path+            return path+          `catchIO` \e -> if isAlreadyExistsError e+                          then findTempName (x+1) else ioError e
+ compiler/GHC/SysTools/Terminal.hs view
@@ -0,0 +1,104 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE ScopedTypeVariables #-}+module GHC.SysTools.Terminal (stderrSupportsAnsiColors) where++import GHC.Prelude++#if defined(MIN_VERSION_terminfo)+import Control.Exception (catch)+import Data.Maybe (fromMaybe)+import System.Console.Terminfo (SetupTermError, Terminal, getCapability,+                                setupTermFromEnv, termColors)+import System.Posix (queryTerminal, stdError)+#elif defined(mingw32_HOST_OS)+import Control.Exception (catch, try)+import Data.Bits ((.|.), (.&.))+import Foreign (Ptr, peek, with)+import qualified Graphics.Win32 as Win32+import qualified System.Win32 as Win32+#endif++import System.IO.Unsafe++#if defined(mingw32_HOST_OS) && !defined(WINAPI)+# if defined(i386_HOST_ARCH)+#  define WINAPI stdcall+# elif defined(x86_64_HOST_ARCH)+#  define WINAPI ccall+# else+#  error unknown architecture+# endif+#endif++-- | Does the controlling terminal support ANSI color sequences?+-- This memoized to avoid thread-safety issues in ncurses (see #17922).+stderrSupportsAnsiColors :: Bool+stderrSupportsAnsiColors = unsafePerformIO stderrSupportsAnsiColors'+{-# NOINLINE stderrSupportsAnsiColors #-}++-- | Check if ANSI escape sequences can be used to control color in stderr.+stderrSupportsAnsiColors' :: IO Bool+stderrSupportsAnsiColors' = do+#if defined(MIN_VERSION_terminfo)+    stderr_available <- queryTerminal stdError+    if stderr_available then+      fmap termSupportsColors setupTermFromEnv+        `catch` \ (_ :: SetupTermError) -> pure False+    else+      pure False+  where+    termSupportsColors :: Terminal -> Bool+    termSupportsColors term = fromMaybe 0 (getCapability term termColors) > 0++#elif defined(mingw32_HOST_OS)+  h <- Win32.getStdHandle Win32.sTD_ERROR_HANDLE+         `catch` \ (_ :: IOError) ->+           pure Win32.nullHANDLE+  if h == Win32.nullHANDLE+    then pure False+    else do+      eMode <- try (getConsoleMode h)+      case eMode of+        Left (_ :: IOError) -> Win32.isMinTTYHandle h+                                 -- Check if the we're in a MinTTY terminal+                                 -- (e.g., Cygwin or MSYS2)+        Right mode+          | modeHasVTP mode -> pure True+          | otherwise       -> enableVTP h mode++  where++    enableVTP :: Win32.HANDLE -> Win32.DWORD -> IO Bool+    enableVTP h mode = do+        setConsoleMode h (modeAddVTP mode)+        modeHasVTP <$> getConsoleMode h+      `catch` \ (_ :: IOError) ->+        pure False++    modeHasVTP :: Win32.DWORD -> Bool+    modeHasVTP mode = mode .&. eNABLE_VIRTUAL_TERMINAL_PROCESSING /= 0++    modeAddVTP :: Win32.DWORD -> Win32.DWORD+    modeAddVTP mode = mode .|. eNABLE_VIRTUAL_TERMINAL_PROCESSING++eNABLE_VIRTUAL_TERMINAL_PROCESSING :: Win32.DWORD+eNABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004++getConsoleMode :: Win32.HANDLE -> IO Win32.DWORD+getConsoleMode h = with 64 $ \ mode -> do+  Win32.failIfFalse_ "GetConsoleMode" (c_GetConsoleMode h mode)+  peek mode++setConsoleMode :: Win32.HANDLE -> Win32.DWORD -> IO ()+setConsoleMode h mode = do+  Win32.failIfFalse_ "SetConsoleMode" (c_SetConsoleMode h mode)++foreign import WINAPI unsafe "windows.h GetConsoleMode" c_GetConsoleMode+  :: Win32.HANDLE -> Ptr Win32.DWORD -> IO Win32.BOOL++foreign import WINAPI unsafe "windows.h SetConsoleMode" c_SetConsoleMode+  :: Win32.HANDLE -> Win32.DWORD -> IO Win32.BOOL++#else+   pure False+#endif
+ compiler/GHC/Tc/Errors/Hole/FitTypes.hs view
@@ -0,0 +1,145 @@+{-# LANGUAGE ExistentialQuantification #-}+module GHC.Tc.Errors.Hole.FitTypes (+  TypedHole (..), HoleFit (..), HoleFitCandidate (..),+  CandPlugin, FitPlugin, HoleFitPlugin (..), HoleFitPluginR (..),+  hfIsLcl, pprHoleFitCand+  ) where++import GHC.Prelude++import GHC.Tc.Types+import GHC.Tc.Types.Constraint+import GHC.Tc.Utils.TcType++import GHC.Types.Name.Reader++import GHC.Hs.Doc+import GHC.Types.Id++import GHC.Utils.Outputable+import GHC.Types.Name++import Data.Function ( on )++data TypedHole = TyH { tyHRelevantCts :: Cts+                       -- ^ Any relevant Cts to the hole+                     , tyHImplics :: [Implication]+                       -- ^ The nested implications of the hole with the+                       --   innermost implication first.+                     , tyHCt :: Maybe Ct+                       -- ^ The hole constraint itself, if available.+                     }++instance Outputable TypedHole where+  ppr (TyH rels implics ct)+    = hang (text "TypedHole") 2+        (ppr rels $+$ ppr implics $+$ ppr ct)+++-- | HoleFitCandidates are passed to hole fit plugins and then+-- checked whether they fit a given typed-hole.+data HoleFitCandidate = IdHFCand Id             -- An id, like locals.+                      | NameHFCand Name         -- A name, like built-in syntax.+                      | GreHFCand GlobalRdrElt  -- A global, like imported ids.+                      deriving (Eq)++instance Outputable HoleFitCandidate where+  ppr = pprHoleFitCand++pprHoleFitCand :: HoleFitCandidate -> SDoc+pprHoleFitCand (IdHFCand cid) = text "Id HFC: " <> ppr cid+pprHoleFitCand (NameHFCand cname) = text "Name HFC: " <> ppr cname+pprHoleFitCand (GreHFCand cgre) = text "Gre HFC: " <> ppr cgre+++++instance NamedThing HoleFitCandidate where+  getName hfc = case hfc of+                     IdHFCand cid -> idName cid+                     NameHFCand cname -> cname+                     GreHFCand cgre -> gre_name cgre+  getOccName hfc = case hfc of+                     IdHFCand cid -> occName cid+                     NameHFCand cname -> occName cname+                     GreHFCand cgre -> occName (gre_name cgre)++instance HasOccName HoleFitCandidate where+  occName = getOccName++instance Ord HoleFitCandidate where+  compare = compare `on` getName++-- | HoleFit is the type we use for valid hole fits. It contains the+-- element that was checked, the Id of that element as found by `tcLookup`,+-- and the refinement level of the fit, which is the number of extra argument+-- holes that this fit uses (e.g. if hfRefLvl is 2, the fit is for `Id _ _`).+data HoleFit =+  HoleFit { hfId   :: Id       -- ^ The elements id in the TcM+          , hfCand :: HoleFitCandidate  -- ^ The candidate that was checked.+          , hfType :: TcType -- ^ The type of the id, possibly zonked.+          , hfRefLvl :: Int  -- ^ The number of holes in this fit.+          , hfWrap :: [TcType] -- ^ The wrapper for the match.+          , hfMatches :: [TcType]+          -- ^ What the refinement variables got matched with, if anything+          , hfDoc :: Maybe HsDocString+          -- ^ Documentation of this HoleFit, if available.+          }+ | RawHoleFit SDoc+ -- ^ A fit that is just displayed as is. Here so thatHoleFitPlugins+ --   can inject any fit they want.++-- We define an Eq and Ord instance to be able to build a graph.+instance Eq HoleFit where+   (==) = (==) `on` hfId++instance Outputable HoleFit where+  ppr (RawHoleFit sd) = sd+  ppr (HoleFit _ cand ty _ _ mtchs _) =+    hang (name <+> holes) 2 (text "where" <+> name <+> dcolon <+> (ppr ty))+    where name = ppr $ getName cand+          holes = sep $ map (parens . (text "_" <+> dcolon <+>) . ppr) mtchs++-- We compare HoleFits by their name instead of their Id, since we don't+-- want our tests to be affected by the non-determinism of `nonDetCmpVar`,+-- which is used to compare Ids. When comparing, we want HoleFits with a lower+-- refinement level to come first.+instance Ord HoleFit where+  compare (RawHoleFit _) (RawHoleFit _) = EQ+  compare (RawHoleFit _) _ = LT+  compare _ (RawHoleFit _) = GT+  compare a@(HoleFit {}) b@(HoleFit {}) = cmp a b+    where cmp  = if hfRefLvl a == hfRefLvl b+                 then compare `on` (getName . hfCand)+                 else compare `on` hfRefLvl++hfIsLcl :: HoleFit -> Bool+hfIsLcl hf@(HoleFit {}) = case hfCand hf of+                            IdHFCand _    -> True+                            NameHFCand _  -> False+                            GreHFCand gre -> gre_lcl gre+hfIsLcl _ = False+++-- | A plugin for modifying the candidate hole fits *before* they're checked.+type CandPlugin = TypedHole -> [HoleFitCandidate] -> TcM [HoleFitCandidate]++-- | A plugin for modifying hole fits  *after* they've been found.+type FitPlugin =  TypedHole -> [HoleFit] -> TcM [HoleFit]++-- | A HoleFitPlugin is a pair of candidate and fit plugins.+data HoleFitPlugin = HoleFitPlugin+  { candPlugin :: CandPlugin+  , fitPlugin :: FitPlugin }++-- | HoleFitPluginR adds a TcRef to hole fit plugins so that plugins can+-- track internal state. Note the existential quantification, ensuring that+-- the state cannot be modified from outside the plugin.+data HoleFitPluginR = forall s. HoleFitPluginR+  { hfPluginInit :: TcM (TcRef s)+    -- ^ Initializes the TcRef to be passed to the plugin+  , hfPluginRun :: TcRef s -> HoleFitPlugin+    -- ^ The function defining the plugin itself+  , hfPluginStop :: TcRef s -> TcM ()+    -- ^ Cleanup of state, guaranteed to be called even on error+  }
+ compiler/GHC/Tc/Errors/Hole/FitTypes.hs-boot view
@@ -0,0 +1,10 @@+-- This boot file is in place to break the loop where:+-- + GHC.Tc.Types needs 'HoleFitPlugin',+-- + which needs 'GHC.Tc.Errors.Hole.FitTypes'+-- + which needs 'GHC.Tc.Types'+module GHC.Tc.Errors.Hole.FitTypes where++-- Build ordering+import GHC.Base()++data HoleFitPlugin
+ compiler/GHC/Tc/Types.hs view
@@ -0,0 +1,1735 @@+{-+(c) The University of Glasgow 2006-2012+(c) The GRASP Project, Glasgow University, 1992-2002++-}++{-# LANGUAGE CPP, DeriveFunctor, ExistentialQuantification, GeneralizedNewtypeDeriving,+             ViewPatterns #-}++-- | Various types used during typechecking.+--+-- Please see GHC.Tc.Utils.Monad as well for operations on these types. You probably+-- want to import it, instead of this module.+--+-- All the monads exported here are built on top of the same IOEnv monad. The+-- monad functions like a Reader monad in the way it passes the environment+-- around. This is done to allow the environment to be manipulated in a stack+-- like fashion when entering expressions... etc.+--+-- For state that is global and should be returned at the end (e.g not part+-- of the stack mechanism), you should use a TcRef (= IORef) to store them.+module GHC.Tc.Types(+        TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module+        TcRef,++        -- The environment types+        Env(..),+        TcGblEnv(..), TcLclEnv(..),+        setLclEnvTcLevel, getLclEnvTcLevel,+        setLclEnvLoc, getLclEnvLoc,+        IfGblEnv(..), IfLclEnv(..),+        tcVisibleOrphanMods,++        -- Frontend types (shouldn't really be here)+        FrontendResult(..),++        -- Renamer types+        ErrCtxt, RecFieldEnv, pushErrCtxt, pushErrCtxtSameOrigin,+        ImportAvails(..), emptyImportAvails, plusImportAvails,+        WhereFrom(..), mkModDeps, modDepsElts,++        -- Typechecker types+        TcTypeEnv, TcBinderStack, TcBinder(..),+        TcTyThing(..), PromotionErr(..),+        IdBindingInfo(..), ClosedTypeId, RhsNames,+        IsGroupClosed(..),+        SelfBootInfo(..),+        pprTcTyThingCategory, pprPECategory, CompleteMatch(..),++        -- Desugaring types+        DsM, DsLclEnv(..), DsGblEnv(..),+        DsMetaEnv, DsMetaVal(..), CompleteMatchMap,+        mkCompleteMatchMap, extendCompleteMatchMap,++        -- Template Haskell+        ThStage(..), SpliceType(..), PendingStuff(..),+        topStage, topAnnStage, topSpliceStage,+        ThLevel, impLevel, outerLevel, thLevel,+        ForeignSrcLang(..),++        -- Arrows+        ArrowCtxt(..),++        -- TcSigInfo+        TcSigFun, TcSigInfo(..), TcIdSigInfo(..),+        TcIdSigInst(..), TcPatSynInfo(..),+        isPartialSig, hasCompleteSig,++        -- Misc other types+        TcId, TcIdSet,+        NameShape(..),+        removeBindingShadowing,+        getPlatform,++        -- Constraint solver plugins+        TcPlugin(..), TcPluginResult(..), TcPluginSolver,+        TcPluginM, runTcPluginM, unsafeTcPluginTcM,+        getEvBindsTcPluginM,++        -- Role annotations+        RoleAnnotEnv, emptyRoleAnnotEnv, mkRoleAnnotEnv,+        lookupRoleAnnot, getRoleAnnots+  ) where++#include "HsVersions.h"++import GHC.Prelude+import GHC.Platform++import GHC.Hs+import GHC.Driver.Types+import GHC.Tc.Types.Evidence+import GHC.Core.Type+import GHC.Core.TyCon  ( TyCon, tyConKind )+import GHC.Core.PatSyn ( PatSyn )+import GHC.Types.Id         ( idType, idName )+import GHC.Types.FieldLabel ( FieldLabel )+import GHC.Tc.Utils.TcType+import GHC.Tc.Types.Constraint+import GHC.Tc.Types.Origin+import GHC.Types.Annotations+import GHC.Core.InstEnv+import GHC.Core.FamInstEnv+import {-# SOURCE #-} GHC.HsToCore.PmCheck.Types (Deltas)+import GHC.Data.IOEnv+import GHC.Types.Name.Reader+import GHC.Types.Name+import GHC.Types.Name.Env+import GHC.Types.Name.Set+import GHC.Types.Avail+import GHC.Types.Var+import GHC.Types.Var.Env+import GHC.Unit+import GHC.Types.SrcLoc+import GHC.Types.Var.Set+import GHC.Utils.Error+import GHC.Types.Unique.FM+import GHC.Types.Basic+import GHC.Data.Bag+import GHC.Driver.Session+import GHC.Utils.Outputable+import GHC.Data.List.SetOps+import GHC.Utils.Fingerprint+import GHC.Utils.Misc+import GHC.Builtin.Names ( isUnboundName )+import GHC.Types.CostCentre.State++import Control.Monad (ap)+import Data.Set      ( Set )+import qualified Data.Set as S++import Data.List ( sort )+import Data.Map ( Map )+import Data.Dynamic  ( Dynamic )+import Data.Typeable ( TypeRep )+import Data.Maybe    ( mapMaybe )+import GHCi.Message+import GHCi.RemoteTypes++import {-# SOURCE #-} GHC.Tc.Errors.Hole.FitTypes ( HoleFitPlugin )++import qualified Language.Haskell.TH as TH++-- | A 'NameShape' is a substitution on 'Name's that can be used+-- to refine the identities of a hole while we are renaming interfaces+-- (see 'GHC.Iface.Rename').  Specifically, a 'NameShape' for+-- 'ns_module_name' @A@, defines a mapping from @{A.T}@+-- (for some 'OccName' @T@) to some arbitrary other 'Name'.+--+-- The most intruiging thing about a 'NameShape', however, is+-- how it's constructed.  A 'NameShape' is *implied* by the+-- exported 'AvailInfo's of the implementor of an interface:+-- if an implementor of signature @<H>@ exports @M.T@, you implicitly+-- define a substitution from @{H.T}@ to @M.T@.  So a 'NameShape'+-- is computed from the list of 'AvailInfo's that are exported+-- by the implementation of a module, or successively merged+-- together by the export lists of signatures which are joining+-- together.+--+-- It's not the most obvious way to go about doing this, but it+-- does seem to work!+--+-- NB: Can't boot this and put it in NameShape because then we+-- start pulling in too many DynFlags things.+data NameShape = NameShape {+        ns_mod_name :: ModuleName,+        ns_exports :: [AvailInfo],+        ns_map :: OccEnv Name+    }+++{-+************************************************************************+*                                                                      *+               Standard monad definition for TcRn+    All the combinators for the monad can be found in GHC.Tc.Utils.Monad+*                                                                      *+************************************************************************++The monad itself has to be defined here, because it is mentioned by ErrCtxt+-}++type TcRnIf a b = IOEnv (Env a b)+type TcRn       = TcRnIf TcGblEnv TcLclEnv    -- Type inference+type IfM lcl    = TcRnIf IfGblEnv lcl         -- Iface stuff+type IfG        = IfM ()                      --    Top level+type IfL        = IfM IfLclEnv                --    Nested+type DsM        = TcRnIf DsGblEnv DsLclEnv    -- Desugaring++-- TcRn is the type-checking and renaming monad: the main monad that+-- most type-checking takes place in.  The global environment is+-- 'TcGblEnv', which tracks all of the top-level type-checking+-- information we've accumulated while checking a module, while the+-- local environment is 'TcLclEnv', which tracks local information as+-- we move inside expressions.++-- | Historical "renaming monad" (now it's just 'TcRn').+type RnM  = TcRn++-- | Historical "type-checking monad" (now it's just 'TcRn').+type TcM  = TcRn++-- We 'stack' these envs through the Reader like monad infrastructure+-- as we move into an expression (although the change is focused in+-- the lcl type).+data Env gbl lcl+  = Env {+        env_top  :: !HscEnv, -- Top-level stuff that never changes+                             -- Includes all info about imported things+                             -- BangPattern is to fix leak, see #15111++        env_um   :: !Char,   -- Mask for Uniques++        env_gbl  :: gbl,     -- Info about things defined at the top level+                             -- of the module being compiled++        env_lcl  :: lcl      -- Nested stuff; changes as we go into+    }++instance ContainsDynFlags (Env gbl lcl) where+    extractDynFlags env = hsc_dflags (env_top env)++instance ContainsModule gbl => ContainsModule (Env gbl lcl) where+    extractModule env = extractModule (env_gbl env)+++{-+************************************************************************+*                                                                      *+                The interface environments+              Used when dealing with IfaceDecls+*                                                                      *+************************************************************************+-}++data IfGblEnv+  = IfGblEnv {+        -- Some information about where this environment came from;+        -- useful for debugging.+        if_doc :: SDoc,+        -- The type environment for the module being compiled,+        -- in case the interface refers back to it via a reference that+        -- was originally a hi-boot file.+        -- We need the module name so we can test when it's appropriate+        -- to look in this env.+        -- See Note [Tying the knot] in GHC.IfaceToCore+        if_rec_types :: Maybe (Module, IfG TypeEnv)+                -- Allows a read effect, so it can be in a mutable+                -- variable; c.f. handling the external package type env+                -- Nothing => interactive stuff, no loops possible+    }++data IfLclEnv+  = IfLclEnv {+        -- The module for the current IfaceDecl+        -- So if we see   f = \x -> x+        -- it means M.f = \x -> x, where M is the if_mod+        -- NB: This is a semantic module, see+        -- Note [Identity versus semantic module]+        if_mod :: Module,++        -- Whether or not the IfaceDecl came from a boot+        -- file or not; we'll use this to choose between+        -- NoUnfolding and BootUnfolding+        if_boot :: Bool,++        -- The field is used only for error reporting+        -- if (say) there's a Lint error in it+        if_loc :: SDoc,+                -- Where the interface came from:+                --      .hi file, or GHCi state, or ext core+                -- plus which bit is currently being examined++        if_nsubst :: Maybe NameShape,++        -- This field is used to make sure "implicit" declarations+        -- (anything that cannot be exported in mi_exports) get+        -- wired up correctly in typecheckIfacesForMerging.  Most+        -- of the time it's @Nothing@.  See Note [Resolving never-exported Names]+        -- in GHC.IfaceToCore.+        if_implicits_env :: Maybe TypeEnv,++        if_tv_env  :: FastStringEnv TyVar,     -- Nested tyvar bindings+        if_id_env  :: FastStringEnv Id         -- Nested id binding+    }++{-+************************************************************************+*                                                                      *+                Desugarer monad+*                                                                      *+************************************************************************++Now the mondo monad magic (yes, @DsM@ is a silly name)---carry around+a @UniqueSupply@ and some annotations, which+presumably include source-file location information:+-}++data DsGblEnv+        = DsGblEnv+        { ds_mod          :: Module             -- For SCC profiling+        , ds_fam_inst_env :: FamInstEnv         -- Like tcg_fam_inst_env+        , ds_unqual  :: PrintUnqualified+        , ds_msgs    :: IORef Messages          -- Warning messages+        , ds_if_env  :: (IfGblEnv, IfLclEnv)    -- Used for looking up global,+                                                -- possibly-imported things+        , ds_complete_matches :: CompleteMatchMap+           -- Additional complete pattern matches+        , ds_cc_st   :: IORef CostCentreState+           -- Tracking indices for cost centre annotations+        }++instance ContainsModule DsGblEnv where+    extractModule = ds_mod++data DsLclEnv = DsLclEnv {+        dsl_meta    :: DsMetaEnv,        -- Template Haskell bindings+        dsl_loc     :: RealSrcSpan,      -- To put in pattern-matching error msgs++        -- See Note [Note [Type and Term Equality Propagation] in Check.hs+        -- 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+-- up variables in the DsMetaEnv+type DsMetaEnv = NameEnv DsMetaVal++data DsMetaVal+   = DsBound Id         -- Bound by a pattern inside the [| |].+                        -- Will be dynamically alpha renamed.+                        -- The Id has type THSyntax.Var++   | DsSplice (HsExpr GhcTc) -- These bindings are introduced by+                             -- the PendingSplices on a HsBracketOut+++{-+************************************************************************+*                                                                      *+                Global typechecker environment+*                                                                      *+************************************************************************+-}++-- | '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 GHC.Driver.Types, but it needs+-- to have a TcGblEnv which is only defined here.+data FrontendResult+        = FrontendTypecheck TcGblEnv++-- Note [Identity versus semantic module]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- When typechecking an hsig file, it is convenient to keep track+-- of two different "this module" identifiers:+--+--      - The IDENTITY module is simply thisPackage + the module+--        name; i.e. it uniquely *identifies* the interface file+--        we're compiling.  For example, p[A=<A>]:A is an+--        identity module identifying the requirement named A+--        from library p.+--+--      - The SEMANTIC module, which is the actual module that+--        this signature is intended to represent (e.g. if+--        we have a identity module p[A=base:Data.IORef]:A,+--        then the semantic module is base:Data.IORef)+--+-- Which one should you use?+--+--      - In the desugarer and later phases of compilation,+--        identity and semantic modules coincide, since we never compile+--        signatures (we just generate blank object files for+--        hsig files.)+--+--        A corrolary of this is that the following invariant holds at any point+--        past desugaring,+--+--            if I have a Module, this_mod, in hand representing the module+--            currently being compiled,+--            then moduleUnit this_mod == thisPackage dflags+--+--      - For any code involving Names, we want semantic modules.+--        See lookupIfaceTop in GHC.Iface.Env, mkIface and addFingerprints+--        in GHC.Iface.{Make,Recomp}, and tcLookupGlobal in GHC.Tc.Utils.Env+--+--      - When reading interfaces, we want the identity module to+--        identify the specific interface we want (such interfaces+--        should never be loaded into the EPS).  However, if a+--        hole module <A> is requested, we look for A.hi+--        in the home library we are compiling.  (See GHC.Iface.Load.)+--        Similarly, in GHC.Rename.Names we check for self-imports using+--        identity modules, to allow signatures to import their implementor.+--+--      - For recompilation avoidance, you want the identity module,+--        since that will actually say the specific interface you+--        want to track (and recompile if it changes)++-- | 'TcGblEnv' describes the top-level of the module at the+-- point at which the typechecker is finished work.+-- It is this structure that is handed on to the desugarer+-- For state that needs to be updated during the typechecking+-- phase and returned at end, use a 'TcRef' (= 'IORef').+data TcGblEnv+  = TcGblEnv {+        tcg_mod     :: Module,         -- ^ Module being compiled+        tcg_semantic_mod :: Module,    -- ^ If a signature, the backing module+            -- See also Note [Identity versus semantic module]+        tcg_src     :: HscSource,+          -- ^ What kind of module (regular Haskell, hs-boot, hsig)++        tcg_rdr_env :: GlobalRdrEnv,   -- ^ Top level envt; used during renaming+        tcg_default :: Maybe [Type],+          -- ^ Types used for defaulting. @Nothing@ => no @default@ decl++        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 GHC.Driver.Types++        tcg_type_env :: TypeEnv,+          -- ^ Global type env for the module we are compiling now.  All+          -- TyCons and Classes (for this module) end up in here right away,+          -- along with their derived constructors, selectors.+          --+          -- (Ids defined in this module start in the local envt, though they+          --  move to the global envt during zonking)+          --+          -- NB: for what "things in this module" means, see+          -- Note [The interactive package] in GHC.Driver.Types++        tcg_type_env_var :: TcRef TypeEnv,+                -- Used only to initialise the interface-file+                -- typechecker in initIfaceTcRn, so that it can see stuff+                -- bound in this module when dealing with hi-boot recursions+                -- Updated at intervals (e.g. after dealing with types and classes)++        tcg_inst_env     :: !InstEnv,+          -- ^ Instance envt for all /home-package/ modules;+          -- Includes the dfuns in tcg_insts+          -- NB. BangPattern is to fix a leak, see #15111+        tcg_fam_inst_env :: !FamInstEnv, -- ^ Ditto for family instances+          -- NB. BangPattern is to fix a leak, see #15111+        tcg_ann_env      :: AnnEnv,     -- ^ And for annotations++                -- Now a bunch of things about this module that are simply+                -- accumulated, but never consulted until the end.+                -- Nevertheless, it's convenient to accumulate them along+                -- with the rest of the info from this module.+        tcg_exports :: [AvailInfo],     -- ^ What is exported+        tcg_imports :: ImportAvails,+          -- ^ Information about what was imported from where, including+          -- things bound in this module. Also store Safe Haskell info+          -- here about transitive trusted package requirements.+          --+          -- There are not many uses of this field, so you can grep for+          -- all them.+          --+          -- The ImportAvails records information about the following+          -- things:+          --+          --    1. All of the modules you directly imported (tcRnImports)+          --    2. The orphans (only!) of all imported modules in a GHCi+          --       session (runTcInteractive)+          --    3. The module that instantiated a signature+          --    4. Each of the signatures that merged in+          --+          -- It is used in the following ways:+          --    - imp_orphs is used to determine what orphan modules should be+          --      visible in the context (tcVisibleOrphanMods)+          --    - imp_finsts is used to determine what family instances should+          --      be visible (tcExtendLocalFamInstEnv)+          --    - To resolve the meaning of the export list of a module+          --      (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 GHC.Driver.Main)+          --    - To create the Dependencies field in interface (mkDependencies)++          -- These three fields track unused bindings and imports+          -- See Note [Tracking unused binding and imports]+        tcg_dus       :: DefUses,+        tcg_used_gres :: TcRef [GlobalRdrElt],+        tcg_keep      :: TcRef NameSet,++        tcg_th_used :: TcRef Bool,+          -- ^ @True@ <=> Template Haskell syntax used.+          --+          -- We need this so that we can generate a dependency on the+          -- Template Haskell package, because the desugarer is going+          -- to emit loads of references to TH symbols.  The reference+          -- is implicit rather than explicit, so we have to zap a+          -- mutable variable.++        tcg_th_splice_used :: TcRef Bool,+          -- ^ @True@ <=> A Template Haskell splice was used.+          --+          -- Splices disable recompilation avoidance (see #481)++        tcg_dfun_n  :: TcRef OccSet,+          -- ^ Allows us to choose unique DFun names.++        tcg_merged :: [(Module, Fingerprint)],+          -- ^ The requirements we merged with; we always have to recompile+          -- if any of these changed.++        -- The next fields accumulate the payload of the module+        -- The binds, rules and foreign-decl fields are collected+        -- initially in un-zonked form and are finally zonked in tcRnSrcDecls++        tcg_rn_exports :: Maybe [(Located (IE GhcRn), Avails)],+                -- Nothing <=> no explicit export list+                -- Is always Nothing if we don't want to retain renamed+                -- exports.+                -- If present contains each renamed export list item+                -- together with its exported names.++        tcg_rn_imports :: [LImportDecl GhcRn],+                -- Keep the renamed imports regardless.  They are not+                -- voluminous and are needed if you want to report unused imports++        tcg_rn_decls :: Maybe (HsGroup GhcRn),+          -- ^ Renamed decls, maybe.  @Nothing@ <=> Don't retain renamed+          -- decls.++        tcg_dependent_files :: TcRef [FilePath], -- ^ dependencies from addDependentFile++        tcg_th_topdecls :: TcRef [LHsDecl GhcPs],+        -- ^ Top-level declarations from addTopDecls++        tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)],+        -- ^ Foreign files emitted from TH.++        tcg_th_topnames :: TcRef NameSet,+        -- ^ Exact names bound in top-level declarations in tcg_th_topdecls++        tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)],+        -- ^ Template Haskell module finalizers.+        --+        -- They can use particular local environments.++        tcg_th_coreplugins :: TcRef [String],+        -- ^ Core plugins added by Template Haskell code.++        tcg_th_state :: TcRef (Map TypeRep Dynamic),+        tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState))),+        -- ^ Template Haskell state++        tcg_ev_binds  :: Bag EvBind,        -- Top-level evidence bindings++        -- 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 GHC.Driver.Types+        tcg_tr_module :: Maybe Id,   -- Id for $trModule :: GHC.Unit.Module+                                             -- for which every module has a top-level defn+                                             -- except in GHCi in which case we have Nothing+        tcg_binds     :: LHsBinds GhcTc,     -- Value bindings in this module+        tcg_sigs      :: NameSet,            -- ...Top-level names that *lack* a signature+        tcg_imp_specs :: [LTcSpecPrag],      -- ...SPECIALISE prags for imported Ids+        tcg_warns     :: Warnings,           -- ...Warnings and deprecations+        tcg_anns      :: [Annotation],       -- ...Annotations+        tcg_tcs       :: [TyCon],            -- ...TyCons and Classes+        tcg_insts     :: [ClsInst],          -- ...Instances+        tcg_fam_insts :: [FamInst],          -- ...Family instances+        tcg_rules     :: [LRuleDecl GhcTc],  -- ...Rules+        tcg_fords     :: [LForeignDecl GhcTc], -- ...Foreign import & exports+        tcg_patsyns   :: [PatSyn],            -- ...Pattern synonyms++        tcg_doc_hdr   :: Maybe LHsDocString, -- ^ Maybe Haddock header docs+        tcg_hpc       :: !AnyHpcUsage,       -- ^ @True@ if any part of the+                                             --  prog uses hpc instrumentation.+           -- NB. BangPattern is to fix a leak, see #15111++        tcg_self_boot :: SelfBootInfo,       -- ^ Whether this module has a+                                             -- corresponding hi-boot file++        tcg_main      :: Maybe Name,         -- ^ The Name of the main+                                             -- function, if this module is+                                             -- the main module.++        tcg_safeInfer :: TcRef (Bool, WarningMessages),+        -- ^ Has the typechecker inferred this module as -XSafe (Safe Haskell)+        -- See Note [Safe Haskell Overlapping Instances Implementation],+        -- although this is used for more than just that failure case.++        tcg_tc_plugins :: [TcPluginSolver],+        -- ^ A list of user-defined plugins for the constraint solver.+        tcg_hf_plugins :: [HoleFitPlugin],+        -- ^ A list of user-defined plugins for hole fit suggestions.++        tcg_top_loc :: RealSrcSpan,+        -- ^ The RealSrcSpan this module came from++        tcg_static_wc :: TcRef WantedConstraints,+          -- ^ Wanted constraints of static forms.+        -- See Note [Constraints in static forms].+        tcg_complete_matches :: [CompleteMatch],++        -- ^ Tracking indices for cost centre annotations+        tcg_cc_st   :: TcRef CostCentreState+    }++-- NB: topModIdentity, not topModSemantic!+-- Definition sites of orphan identities will be identity modules, not semantic+-- modules.++-- Note [Constraints in static forms]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- When a static form produces constraints like+--+-- f :: StaticPtr (Bool -> String)+-- f = static show+--+-- we collect them in tcg_static_wc and resolve them at the end+-- of type checking. They need to be resolved separately because+-- we don't want to resolve them in the context of the enclosing+-- expression. Consider+--+-- g :: Show a => StaticPtr (a -> String)+-- g = static show+--+-- If the @Show a0@ constraint that the body of the static form produces was+-- resolved in the context of the enclosing expression, then the body of the+-- static form wouldn't be closed because the Show dictionary would come from+-- g's context instead of coming from the top level.++tcVisibleOrphanMods :: TcGblEnv -> ModuleSet+tcVisibleOrphanMods tcg_env+    = mkModuleSet (tcg_mod tcg_env : imp_orphs (tcg_imports tcg_env))++instance ContainsModule TcGblEnv where+    extractModule env = tcg_semantic_mod env++type RecFieldEnv = NameEnv [FieldLabel]+        -- Maps a constructor name *in this module*+        -- to the fields for that constructor.+        -- This is used when dealing with ".." notation in record+        -- construction and pattern matching.+        -- The FieldEnv deals *only* with constructors defined in *this*+        -- module.  For imported modules, we get the same info from the+        -- TypeEnv++data SelfBootInfo+  = NoSelfBoot    -- No corresponding hi-boot file+  | SelfBoot+       { sb_mds :: ModDetails   -- There was a hi-boot file,+       , sb_tcs :: NameSet }    -- defining these TyCons,+-- What is sb_tcs used for?  See Note [Extra dependencies from .hs-boot files]+-- in GHC.Rename.Module+++{- Note [Tracking unused binding and imports]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We gather three sorts of usage information++ * tcg_dus :: DefUses (defs/uses)+      Records what is defined in this module and what is used.++      Records *defined* Names (local, top-level)+          and *used*    Names (local or imported)++      Used (a) to report "defined but not used"+               (see GHC.Rename.Names.reportUnusedNames)+           (b) to generate version-tracking usage info in interface+               files (see GHC.Iface.Make.mkUsedNames)+   This usage info is mainly gathered by the renamer's+   gathering of free-variables++ * tcg_used_gres :: TcRef [GlobalRdrElt]+      Records occurrences of imported entities.++      Used only to report unused import declarations++      Records each *occurrence* an *imported* (not locally-defined) entity.+      The occurrence is recorded by keeping a GlobalRdrElt for it.+      These is not the GRE that is in the GlobalRdrEnv; rather it+      is recorded *after* the filtering done by pickGREs.  So it reflect+      /how that occurrence is in scope/.   See Note [GRE filtering] in+      RdrName.++  * tcg_keep :: TcRef NameSet+      Records names of the type constructors, data constructors, and Ids that+      are used by the constraint solver.++      The typechecker may use find that some imported or+      locally-defined things are used, even though they+      do not appear to be mentioned in the source code:++      (a) The to/from functions for generic data types++      (b) Top-level variables appearing free in the RHS of an+          orphan rule++      (c) Top-level variables appearing free in a TH bracket+          See Note [Keeping things alive for Template Haskell]+          in GHC.Rename.Splice++      (d) The data constructor of a newtype that is used+          to solve a Coercible instance (e.g. #10347). Example+              module T10347 (N, mkN) where+                import Data.Coerce+                newtype N a = MkN Int+                mkN :: Int -> N a+                mkN = coerce++          Then we wish to record `MkN` as used, since it is (morally)+          used to perform the coercion in `mkN`. To do so, the+          Coercible solver updates tcg_keep's TcRef whenever it+          encounters a use of `coerce` that crosses newtype boundaries.++      The tcg_keep field is used in two distinct ways:++      * Desugar.addExportFlagsAndRules.  Where things like (a-c) are locally+        defined, we should give them an an Exported flag, so that the+        simplifier does not discard them as dead code, and so that they are+        exposed in the interface file (but not to export to the user).++      * GHC.Rename.Names.reportUnusedNames.  Where newtype data constructors+        like (d) are imported, we don't want to report them as unused.+++************************************************************************+*                                                                      *+                The local typechecker environment+*                                                                      *+************************************************************************++Note [The Global-Env/Local-Env story]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+During type checking, we keep in the tcg_type_env+        * All types and classes+        * All Ids derived from types and classes (constructors, selectors)++At the end of type checking, we zonk the local bindings,+and as we do so we add to the tcg_type_env+        * Locally defined top-level Ids++Why?  Because they are now Ids not TcIds.  This final GlobalEnv is+        a) fed back (via the knot) to typechecking the+           unfoldings of interface signatures+        b) used in the ModDetails of this module+-}++data TcLclEnv           -- Changes as we move inside an expression+                        -- Discarded after typecheck/rename; not passed on to desugarer+  = TcLclEnv {+        tcl_loc        :: RealSrcSpan,     -- Source span+        tcl_ctxt       :: [ErrCtxt],       -- Error context, innermost on top+        tcl_tclvl      :: TcLevel,         -- Birthplace for new unification variables++        tcl_th_ctxt    :: ThStage,         -- Template Haskell context+        tcl_th_bndrs   :: ThBindEnv,       -- and binder info+            -- The ThBindEnv records the TH binding level of in-scope Names+            -- defined in this module (not imported)+            -- We can't put this info in the TypeEnv because it's needed+            -- (and extended) in the renamer, for untyed splices++        tcl_arrow_ctxt :: ArrowCtxt,       -- Arrow-notation context++        tcl_rdr :: LocalRdrEnv,         -- Local name envt+                -- Maintained during renaming, of course, but also during+                -- type checking, solely so that when renaming a Template-Haskell+                -- splice we have the right environment for the renamer.+                --+                --   Does *not* include global name envt; may shadow it+                --   Includes both ordinary variables and type variables;+                --   they are kept distinct because tyvar have a different+                --   occurrence constructor (Name.TvOcc)+                -- We still need the unsullied global name env so that+                --   we can look up record field names++        tcl_env  :: TcTypeEnv,    -- The local type environment:+                                  -- Ids and TyVars defined in this module++        tcl_bndrs :: TcBinderStack,   -- Used for reporting relevant bindings,+                                      -- and for tidying types++        tcl_lie  :: TcRef WantedConstraints,    -- Place to accumulate type constraints+        tcl_errs :: TcRef Messages              -- Place to accumulate errors+    }++setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv+setLclEnvTcLevel env lvl = env { tcl_tclvl = lvl }++getLclEnvTcLevel :: TcLclEnv -> TcLevel+getLclEnvTcLevel = tcl_tclvl++setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv+setLclEnvLoc env loc = env { tcl_loc = loc }++getLclEnvLoc :: TcLclEnv -> RealSrcSpan+getLclEnvLoc = tcl_loc++type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))+        -- Monadic so that we have a chance+        -- to deal with bound type variables just before error+        -- message construction++        -- Bool:  True <=> this is a landmark context; do not+        --                 discard it when trimming for display++-- These are here to avoid module loops: one might expect them+-- in GHC.Tc.Types.Constraint, but they refer to ErrCtxt which refers to TcM.+-- Easier to just keep these definitions here, alongside TcM.+pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc+pushErrCtxt o err loc@(CtLoc { ctl_env = lcl })+  = loc { ctl_origin = o, ctl_env = lcl { tcl_ctxt = err : tcl_ctxt lcl } }++pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc+-- Just add information w/o updating the origin!+pushErrCtxtSameOrigin err loc@(CtLoc { ctl_env = lcl })+  = loc { ctl_env = lcl { tcl_ctxt = err : tcl_ctxt lcl } }++type TcTypeEnv = NameEnv TcTyThing++type ThBindEnv = NameEnv (TopLevelFlag, ThLevel)+   -- Domain = all Ids bound in this module (ie not imported)+   -- The TopLevelFlag tells if the binding is syntactically top level.+   -- We need to know this, because the cross-stage persistence story allows+   -- cross-stage at arbitrary types if the Id is bound at top level.+   --+   -- Nota bene: a ThLevel of 'outerLevel' is *not* the same as being+   -- bound at top level!  See Note [Template Haskell levels] in GHC.Tc.Gen.Splice++{- Note [Given Insts]+   ~~~~~~~~~~~~~~~~~~+Because of GADTs, we have to pass inwards the Insts provided by type signatures+and existential contexts. Consider+        data T a where { T1 :: b -> b -> T [b] }+        f :: Eq a => T a -> Bool+        f (T1 x y) = [x]==[y]++The constructor T1 binds an existential variable 'b', and we need Eq [b].+Well, we have it, because Eq a refines to Eq [b], but we can only spot that if we+pass it inwards.++-}++-- | Type alias for 'IORef'; the convention is we'll use this for mutable+-- bits of data in 'TcGblEnv' which are updated during typechecking and+-- returned at the end.+type TcRef a     = IORef a+-- ToDo: when should I refer to it as a 'TcId' instead of an 'Id'?+type TcId        = Id+type TcIdSet     = IdSet++---------------------------+-- The TcBinderStack+---------------------------++type TcBinderStack = [TcBinder]+   -- This is a stack of locally-bound ids and tyvars,+   --   innermost on top+   -- Used only in error reporting (relevantBindings in TcError),+   --   and in tidying+   -- We can't use the tcl_env type environment, because it doesn't+   --   keep track of the nesting order++data TcBinder+  = TcIdBndr+       TcId+       TopLevelFlag    -- Tells whether the binding is syntactically top-level+                       -- (The monomorphic Ids for a recursive group count+                       --  as not-top-level for this purpose.)++  | TcIdBndr_ExpType  -- Variant that allows the type to be specified as+                      -- an ExpType+       Name+       ExpType+       TopLevelFlag++  | TcTvBndr          -- e.g.   case x of P (y::a) -> blah+       Name           -- We bind the lexical name "a" to the type of y,+       TyVar          -- which might be an utterly different (perhaps+                      -- existential) tyvar++instance Outputable TcBinder where+   ppr (TcIdBndr id top_lvl)           = ppr id <> brackets (ppr top_lvl)+   ppr (TcIdBndr_ExpType id _ top_lvl) = ppr id <> brackets (ppr top_lvl)+   ppr (TcTvBndr name tv)              = ppr name <+> ppr tv++instance HasOccName TcBinder where+    occName (TcIdBndr id _)             = occName (idName id)+    occName (TcIdBndr_ExpType name _ _) = occName name+    occName (TcTvBndr name _)           = occName name++-- fixes #12177+-- Builds up a list of bindings whose OccName has not been seen before+-- i.e., If    ys  = removeBindingShadowing xs+-- then+--  - ys is obtained from xs by deleting some elements+--  - ys has no duplicate OccNames+--  - The first duplicated OccName in xs is retained in ys+-- Overloaded so that it can be used for both GlobalRdrElt in typed-hole+-- substitutions and TcBinder when looking for relevant bindings.+removeBindingShadowing :: HasOccName a => [a] -> [a]+removeBindingShadowing bindings = reverse $ fst $ foldl+    (\(bindingAcc, seenNames) binding ->+    if occName binding `elemOccSet` seenNames -- if we've seen it+        then (bindingAcc, seenNames)              -- skip it+        else (binding:bindingAcc, extendOccSet seenNames (occName binding)))+    ([], emptyOccSet) bindings+++-- | Get target platform+getPlatform :: TcM Platform+getPlatform = targetPlatform <$> getDynFlags++---------------------------+-- Template Haskell stages and levels+---------------------------++data SpliceType = Typed | Untyped++data ThStage    -- See Note [Template Haskell state diagram]+                -- and Note [Template Haskell levels] in GHC.Tc.Gen.Splice+    -- Start at:   Comp+    -- At bracket: wrap current stage in Brack+    -- At splice:  currently Brack: return to previous stage+    --             currently Comp/Splice: compile and run+  = Splice SpliceType -- Inside a top-level splice+                      -- This code will be run *at compile time*;+                      --   the result replaces the splice+                      -- Binding level = 0++  | RunSplice (TcRef [ForeignRef (TH.Q ())])+      -- Set when running a splice, i.e. NOT when renaming or typechecking the+      -- Haskell code for the splice. See Note [RunSplice ThLevel].+      --+      -- Contains a list of mod finalizers collected while executing the splice.+      --+      -- 'addModFinalizer' inserts finalizers here, and from here they are taken+      -- to construct an @HsSpliced@ annotation for untyped splices. See Note+      -- [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice.+      --+      -- For typed splices, the typechecker takes finalizers from here and+      -- inserts them in the list of finalizers in the global environment.+      --+      -- See Note [Collecting modFinalizers in typed splices] in "GHC.Tc.Gen.Splice".++  | Comp        -- Ordinary Haskell code+                -- Binding level = 1++  | Brack                       -- Inside brackets+      ThStage                   --   Enclosing stage+      PendingStuff++data PendingStuff+  = RnPendingUntyped              -- Renaming the inside of an *untyped* bracket+      (TcRef [PendingRnSplice])   -- Pending splices in here++  | RnPendingTyped                -- Renaming the inside of a *typed* bracket++  | TcPending                     -- Typechecking the inside of a typed bracket+      (TcRef [PendingTcSplice])   --   Accumulate pending splices here+      (TcRef WantedConstraints)   --     and type constraints here+      QuoteWrapper                -- A type variable and evidence variable+                                  -- for the overall monad of+                                  -- the bracket. Splices are checked+                                  -- against this monad. The evidence+                                  -- variable is used for desugaring+                                  -- `lift`.+++topStage, topAnnStage, topSpliceStage :: ThStage+topStage       = Comp+topAnnStage    = Splice Untyped+topSpliceStage = Splice Untyped++instance Outputable ThStage where+   ppr (Splice _)    = text "Splice"+   ppr (RunSplice _) = text "RunSplice"+   ppr Comp          = text "Comp"+   ppr (Brack s _)   = text "Brack" <> parens (ppr s)++type ThLevel = Int+    -- NB: see Note [Template Haskell levels] in GHC.Tc.Gen.Splice+    -- Incremented when going inside a bracket,+    -- decremented when going inside a splice+    -- NB: ThLevel is one greater than the 'n' in Fig 2 of the+    --     original "Template meta-programming for Haskell" paper++impLevel, outerLevel :: ThLevel+impLevel = 0    -- Imported things; they can be used inside a top level splice+outerLevel = 1  -- Things defined outside brackets++thLevel :: ThStage -> ThLevel+thLevel (Splice _)    = 0+thLevel Comp          = 1+thLevel (Brack s _)   = thLevel s + 1+thLevel (RunSplice _) = panic "thLevel: called when running a splice"+                        -- See Note [RunSplice ThLevel].++{- Node [RunSplice ThLevel]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The 'RunSplice' stage is set when executing a splice, and only when running a+splice. In particular it is not set when the splice is renamed or typechecked.++'RunSplice' is needed to provide a reference where 'addModFinalizer' can insert+the finalizer (see Note [Delaying modFinalizers in untyped splices]), and+'addModFinalizer' runs when doing Q things. Therefore, It doesn't make sense to+set 'RunSplice' when renaming or typechecking the splice, where 'Splice',+'Brack' or 'Comp' are used instead.++-}++---------------------------+-- Arrow-notation context+---------------------------++{- Note [Escaping the arrow scope]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In arrow notation, a variable bound by a proc (or enclosed let/kappa)+is not in scope to the left of an arrow tail (-<) or the head of (|..|).+For example++        proc x -> (e1 -< e2)++Here, x is not in scope in e1, but it is in scope in e2.  This can get+a bit complicated:++        let x = 3 in+        proc y -> (proc z -> e1) -< e2++Here, x and z are in scope in e1, but y is not.++We implement this by+recording the environment when passing a proc (using newArrowScope),+and returning to that (using escapeArrowScope) on the left of -< and the+head of (|..|).++All this can be dealt with by the *renamer*. But the type checker needs+to be involved too.  Example (arrowfail001)+  class Foo a where foo :: a -> ()+  data Bar = forall a. Foo a => Bar a+  get :: Bar -> ()+  get = proc x -> case x of Bar a -> foo -< a+Here the call of 'foo' gives rise to a (Foo a) constraint that should not+be captured by the pattern match on 'Bar'.  Rather it should join the+constraints from further out.  So we must capture the constraint bag+from further out in the ArrowCtxt that we push inwards.+-}++data ArrowCtxt   -- Note [Escaping the arrow scope]+  = NoArrowCtxt+  | ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)+++---------------------------+-- TcTyThing+---------------------------++-- | A typecheckable thing available in a local context.  Could be+-- 'AGlobal' 'TyThing', but also lexically scoped variables, etc.+-- See 'GHC.Tc.Utils.Env' for how to retrieve a 'TyThing' given a 'Name'.+data TcTyThing+  = AGlobal TyThing             -- Used only in the return type of a lookup++  | ATcId           -- Ids defined in this module; may not be fully zonked+      { tct_id   :: TcId+      , tct_info :: IdBindingInfo   -- See Note [Meaning of IdBindingInfo]+      }++  | ATyVar  Name TcTyVar   -- See Note [Type variables in the type environment]++  | ATcTyCon TyCon   -- Used temporarily, during kind checking, for the+                     -- tycons and clases in this recursive group+                     -- The TyCon is always a TcTyCon.  Its kind+                     -- can be a mono-kind or a poly-kind; in TcTyClsDcls see+                     -- Note [Type checking recursive type and class declarations]++  | APromotionErr PromotionErr++data PromotionErr+  = TyConPE          -- TyCon used in a kind before we are ready+                     --     data T :: T -> * where ...+  | ClassPE          -- Ditto Class++  | FamDataConPE     -- Data constructor for a data family+                     -- See Note [AFamDataCon: not promoting data family constructors]+                     -- in GHC.Tc.Utils.Env.+  | ConstrainedDataConPE PredType+                     -- Data constructor with a non-equality context+                     -- See Note [Don't promote data constructors with+                     --           non-equality contexts] in GHC.Tc.Gen.HsType+  | PatSynPE         -- Pattern synonyms+                     -- See Note [Don't promote pattern synonyms] in GHC.Tc.Utils.Env++  | RecDataConPE     -- Data constructor in a recursive loop+                     -- See Note [Recursion and promoting data constructors] in GHC.Tc.TyCl+  | NoDataKindsTC    -- -XDataKinds not enabled (for a tycon)+  | NoDataKindsDC    -- -XDataKinds not enabled (for a datacon)++instance Outputable TcTyThing where     -- Debugging only+   ppr (AGlobal g)      = ppr g+   ppr elt@(ATcId {})   = text "Identifier" <>+                          brackets (ppr (tct_id elt) <> dcolon+                                 <> ppr (varType (tct_id elt)) <> comma+                                 <+> ppr (tct_info elt))+   ppr (ATyVar n tv)    = text "Type variable" <+> quotes (ppr n) <+> equals <+> ppr tv+                            <+> dcolon <+> ppr (varType tv)+   ppr (ATcTyCon tc)    = text "ATcTyCon" <+> ppr tc <+> dcolon <+> ppr (tyConKind tc)+   ppr (APromotionErr err) = text "APromotionErr" <+> ppr err++-- | IdBindingInfo describes how an Id is bound.+--+-- It is used for the following purposes:+-- a) for static forms in GHC.Tc.Gen.Expr.checkClosedInStaticForm and+-- b) to figure out when a nested binding can be generalised,+--    in GHC.Tc.Gen.Bind.decideGeneralisationPlan.+--+data IdBindingInfo -- See Note [Meaning of IdBindingInfo and ClosedTypeId]+    = NotLetBound+    | ClosedLet+    | NonClosedLet+         RhsNames        -- Used for (static e) checks only+         ClosedTypeId    -- Used for generalisation checks+                         -- and for (static e) checks++-- | IsGroupClosed describes a group of mutually-recursive bindings+data IsGroupClosed+  = IsGroupClosed+      (NameEnv RhsNames)  -- Free var info for the RHS of each binding in the goup+                          -- Used only for (static e) checks++      ClosedTypeId        -- True <=> all the free vars of the group are+                          --          imported or ClosedLet or+                          --          NonClosedLet with ClosedTypeId=True.+                          --          In particular, no tyvars, no NotLetBound++type RhsNames = NameSet   -- Names of variables, mentioned on the RHS of+                          -- a definition, that are not Global or ClosedLet++type ClosedTypeId = Bool+  -- See Note [Meaning of IdBindingInfo and ClosedTypeId]++{- Note [Meaning of IdBindingInfo]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+NotLetBound means that+  the Id is not let-bound (e.g. it is bound in a+  lambda-abstraction or in a case pattern)++ClosedLet means that+   - The Id is let-bound,+   - Any free term variables are also Global or ClosedLet+   - Its type has no free variables (NB: a top-level binding subject+     to the MR might have free vars in its type)+   These ClosedLets can definitely be floated to top level; and we+   may need to do so for static forms.++   Property:   ClosedLet+             is equivalent to+               NonClosedLet emptyNameSet True++(NonClosedLet (fvs::RhsNames) (cl::ClosedTypeId)) means that+   - The Id is let-bound++   - The fvs::RhsNames contains the free names of the RHS,+     excluding Global and ClosedLet ones.++   - For the ClosedTypeId field see Note [Bindings with closed types]++For (static e) to be valid, we need for every 'x' free in 'e',+that x's binding is floatable to the top level.  Specifically:+   * x's RhsNames must be empty+   * x's type has no free variables+See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.hs.+This test is made in GHC.Tc.Gen.Expr.checkClosedInStaticForm.+Actually knowing x's RhsNames (rather than just its emptiness+or otherwise) is just so we can produce better error messages++Note [Bindings with closed types: ClosedTypeId]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider++  f x = let g ys = map not ys+        in ...++Can we generalise 'g' under the OutsideIn algorithm?  Yes,+because all g's free variables are top-level; that is they themselves+have no free type variables, and it is the type variables in the+environment that makes things tricky for OutsideIn generalisation.++Here's the invariant:+   If an Id has ClosedTypeId=True (in its IdBindingInfo), then+   the Id's type is /definitely/ closed (has no free type variables).+   Specifically,+       a) The Id's actual type is closed (has no free tyvars)+       b) Either the Id has a (closed) user-supplied type signature+          or all its free variables are Global/ClosedLet+             or NonClosedLet with ClosedTypeId=True.+          In particular, none are NotLetBound.++Why is (b) needed?   Consider+    \x. (x :: Int, let y = x+1 in ...)+Initially x::alpha.  If we happen to typecheck the 'let' before the+(x::Int), y's type will have a free tyvar; but if the other way round+it won't.  So we treat any let-bound variable with a free+non-let-bound variable as not ClosedTypeId, regardless of what the+free vars of its type actually are.++But if it has a signature, all is well:+   \x. ...(let { y::Int; y = x+1 } in+           let { v = y+2 } in ...)...+Here the signature on 'v' makes 'y' a ClosedTypeId, so we can+generalise 'v'.++Note that:++  * A top-level binding may not have ClosedTypeId=True, if it suffers+    from the MR++  * A nested binding may be closed (eg 'g' in the example we started+    with). Indeed, that's the point; whether a function is defined at+    top level or nested is orthogonal to the question of whether or+    not it is closed.++  * A binding may be non-closed because it mentions a lexically scoped+    *type variable*  Eg+        f :: forall a. blah+        f x = let g y = ...(y::a)...++Under OutsideIn we are free to generalise an Id all of whose free+variables have ClosedTypeId=True (or imported).  This is an extension+compared to the JFP paper on OutsideIn, which used "top-level" as a+proxy for "closed".  (It's not a good proxy anyway -- the MR can make+a top-level binding with a free type variable.)++Note [Type variables in the type environment]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The type environment has a binding for each lexically-scoped+type variable that is in scope.  For example++  f :: forall a. a -> a+  f x = (x :: a)++  g1 :: [a] -> a+  g1 (ys :: [b]) = head ys :: b++  g2 :: [Int] -> Int+  g2 (ys :: [c]) = head ys :: c++* The forall'd variable 'a' in the signature scopes over f's RHS.++* The pattern-bound type variable 'b' in 'g1' scopes over g1's+  RHS; note that it is bound to a skolem 'a' which is not itself+  lexically in scope.++* The pattern-bound type variable 'c' in 'g2' is bound to+  Int; that is, pattern-bound type variables can stand for+  arbitrary types. (see+    GHC proposal #128 "Allow ScopedTypeVariables to refer to types"+    https://github.com/ghc-proposals/ghc-proposals/pull/128,+  and the paper+    "Type variables in patterns", Haskell Symposium 2018.+++This is implemented by the constructor+   ATyVar Name TcTyVar+in the type environment.++* The Name is the name of the original, lexically scoped type+  variable++* The TcTyVar is sometimes a skolem (like in 'f'), and sometimes+  a unification variable (like in 'g1', 'g2').  We never zonk the+  type environment so in the latter case it always stays as a+  unification variable, although that variable may be later+  unified with a type (such as Int in 'g2').+-}++instance Outputable IdBindingInfo where+  ppr NotLetBound = text "NotLetBound"+  ppr ClosedLet = text "TopLevelLet"+  ppr (NonClosedLet fvs closed_type) =+    text "TopLevelLet" <+> ppr fvs <+> ppr closed_type++instance Outputable PromotionErr where+  ppr ClassPE                     = text "ClassPE"+  ppr TyConPE                     = text "TyConPE"+  ppr PatSynPE                    = text "PatSynPE"+  ppr FamDataConPE                = text "FamDataConPE"+  ppr (ConstrainedDataConPE pred) = text "ConstrainedDataConPE"+                                      <+> parens (ppr pred)+  ppr RecDataConPE                = text "RecDataConPE"+  ppr NoDataKindsTC               = text "NoDataKindsTC"+  ppr NoDataKindsDC               = text "NoDataKindsDC"++pprTcTyThingCategory :: TcTyThing -> SDoc+pprTcTyThingCategory (AGlobal thing)    = pprTyThingCategory thing+pprTcTyThingCategory (ATyVar {})        = text "Type variable"+pprTcTyThingCategory (ATcId {})         = text "Local identifier"+pprTcTyThingCategory (ATcTyCon {})     = text "Local tycon"+pprTcTyThingCategory (APromotionErr pe) = pprPECategory pe++pprPECategory :: PromotionErr -> SDoc+pprPECategory ClassPE                = text "Class"+pprPECategory TyConPE                = text "Type constructor"+pprPECategory PatSynPE               = text "Pattern synonym"+pprPECategory FamDataConPE           = text "Data constructor"+pprPECategory ConstrainedDataConPE{} = text "Data constructor"+pprPECategory RecDataConPE           = text "Data constructor"+pprPECategory NoDataKindsTC          = text "Type constructor"+pprPECategory NoDataKindsDC          = text "Data constructor"++{-+************************************************************************+*                                                                      *+        Operations over ImportAvails+*                                                                      *+************************************************************************+-}++-- | 'ImportAvails' summarises what was imported from where, irrespective of+-- whether the imported things are actually used or not.  It is used:+--+--  * when processing the export list,+--+--  * when constructing usage info for the interface file,+--+--  * to identify the list of directly imported modules for initialisation+--    purposes and for optimised overlap checking of family instances,+--+--  * when figuring out what things are really unused+--+data ImportAvails+   = ImportAvails {+        imp_mods :: ImportedMods,+          --      = ModuleEnv [ImportedModsVal],+          -- ^ Domain is all directly-imported modules+          --+          -- 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,+          -- because we might be importing modules of the same name from+          -- different packages. (currently not the case, but might be in the+          -- future).++        imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface),+          -- ^ Home-package modules needed by the module being compiled+          --+          -- It doesn't matter whether any of these dependencies+          -- are actually /used/ when compiling the module; they+          -- are listed if they are below it at all.  For+          -- example, suppose M imports A which imports X.  Then+          -- compiling M might not need to consult X.hi, but X+          -- is still listed in M's dependencies.++        imp_dep_pkgs :: Set UnitId,+          -- ^ Packages needed by the module being compiled, whether directly,+          -- or via other modules in this package, or via modules imported+          -- from other packages.++        imp_trust_pkgs :: Set UnitId,+          -- ^ This is strictly a subset of imp_dep_pkgs and records the+          -- packages the current module needs to trust for Safe Haskell+          -- compilation to succeed. A package is required to be trusted if+          -- we are dependent on a trustworthy module in that package.+          -- While perhaps making imp_dep_pkgs a tuple of (UnitId, Bool)+          -- where True for the bool indicates the package is required to be+          -- trusted is the more logical  design, doing so complicates a lot+          -- of code not concerned with Safe Haskell.+          -- See Note [Tracking Trust Transitively] in GHC.Rename.Names++        imp_trust_own_pkg :: Bool,+          -- ^ Do we require that our own package is trusted?+          -- This is to handle efficiently the case where a Safe module imports+          -- a Trustworthy module that resides in the same package as it.+          -- See Note [Trust Own Package] in GHC.Rename.Names++        imp_orphs :: [Module],+          -- ^ Orphan modules below us in the import tree (and maybe including+          -- us for imported modules)++        imp_finsts :: [Module]+          -- ^ Family instance modules below us in the import tree (and maybe+          -- including us for imported modules)+      }++mkModDeps :: [(ModuleName, IsBootInterface)]+          -> ModuleNameEnv (ModuleName, IsBootInterface)+mkModDeps deps = foldl' add emptyUFM deps+               where+                 add env elt@(m,_) = addToUFM env m elt++modDepsElts+  :: ModuleNameEnv (ModuleName, IsBootInterface)+  -> [(ModuleName, IsBootInterface)]+modDepsElts = sort . nonDetEltsUFM+  -- It's OK to use nonDetEltsUFM here because sorting by module names+  -- restores determinism++emptyImportAvails :: ImportAvails+emptyImportAvails = ImportAvails { imp_mods          = emptyModuleEnv,+                                   imp_dep_mods      = emptyUFM,+                                   imp_dep_pkgs      = S.empty,+                                   imp_trust_pkgs    = S.empty,+                                   imp_trust_own_pkg = False,+                                   imp_orphs         = [],+                                   imp_finsts        = [] }++-- | Union two ImportAvails+--+-- This function is a key part of Import handling, basically+-- for each import we create a separate ImportAvails structure+-- and then union them all together with this function.+plusImportAvails ::  ImportAvails ->  ImportAvails ->  ImportAvails+plusImportAvails+  (ImportAvails { imp_mods = mods1,+                  imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1,+                  imp_trust_pkgs = tpkgs1, imp_trust_own_pkg = tself1,+                  imp_orphs = orphs1, imp_finsts = finsts1 })+  (ImportAvails { imp_mods = mods2,+                  imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,+                  imp_trust_pkgs = tpkgs2, imp_trust_own_pkg = tself2,+                  imp_orphs = orphs2, imp_finsts = finsts2 })+  = ImportAvails { imp_mods          = plusModuleEnv_C (++) mods1 mods2,+                   imp_dep_mods      = plusUFM_C plus_mod_dep dmods1 dmods2,+                   imp_dep_pkgs      = dpkgs1 `S.union` dpkgs2,+                   imp_trust_pkgs    = tpkgs1 `S.union` tpkgs2,+                   imp_trust_own_pkg = tself1 || tself2,+                   imp_orphs         = orphs1 `unionLists` orphs2,+                   imp_finsts        = finsts1 `unionLists` finsts2 }+  where+    plus_mod_dep r1@(m1, boot1) r2@(m2, boot2)+      | ASSERT2( m1 == m2, (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )+        boot1 = r2+      | otherwise = r1+      -- If either side can "see" a non-hi-boot interface, use that+      -- Reusing existing tuples saves 10% of allocations on test+      -- perf/compiler/MultiLayerModules++{-+************************************************************************+*                                                                      *+\subsection{Where from}+*                                                                      *+************************************************************************++The @WhereFrom@ type controls where the renamer looks for an interface file+-}++data WhereFrom+  = ImportByUser IsBootInterface        -- Ordinary user import (perhaps {-# SOURCE #-})+  | ImportBySystem                      -- Non user import.+  | ImportByPlugin                      -- Importing a plugin;+                                        -- See Note [Care with plugin imports] in GHC.Iface.Load++instance Outputable WhereFrom where+  ppr (ImportByUser is_boot) | is_boot     = text "{- SOURCE -}"+                             | otherwise   = empty+  ppr ImportBySystem                       = text "{- SYSTEM -}"+  ppr ImportByPlugin                       = text "{- PLUGIN -}"+++{- *********************************************************************+*                                                                      *+                Type signatures+*                                                                      *+********************************************************************* -}++-- These data types need to be here only because+-- GHC.Tc.Solver uses them, and GHC.Tc.Solver is fairly+-- low down in the module hierarchy++type TcSigFun  = Name -> Maybe TcSigInfo++data TcSigInfo = TcIdSig     TcIdSigInfo+               | TcPatSynSig TcPatSynInfo++data TcIdSigInfo   -- See Note [Complete and partial type signatures]+  = CompleteSig    -- A complete signature with no wildcards,+                   -- so the complete polymorphic type is known.+      { sig_bndr :: TcId          -- The polymorphic Id with that type++      , sig_ctxt :: UserTypeCtxt  -- In the case of type-class default methods,+                                  -- the Name in the FunSigCtxt is not the same+                                  -- as the TcId; the former is 'op', while the+                                  -- latter is '$dmop' or some such++      , sig_loc  :: SrcSpan       -- Location of the type signature+      }++  | PartialSig     -- A partial type signature (i.e. includes one or more+                   -- wildcards). In this case it doesn't make sense to give+                   -- the polymorphic Id, because we are going to /infer/ its+                   -- type, so we can't make the polymorphic Id ab-initio+      { psig_name  :: Name   -- Name of the function; used when report wildcards+      , psig_hs_ty :: LHsSigWcType GhcRn  -- The original partial signature in+                                          -- HsSyn form+      , sig_ctxt   :: UserTypeCtxt+      , sig_loc    :: SrcSpan            -- Location of the type signature+      }+++{- Note [Complete and partial type signatures]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A type signature is partial when it contains one or more wildcards+(= type holes).  The wildcard can either be:+* A (type) wildcard occurring in sig_theta or sig_tau. These are+  stored in sig_wcs.+      f :: Bool -> _+      g :: Eq _a => _a -> _a -> Bool+* Or an extra-constraints wildcard, stored in sig_cts:+      h :: (Num a, _) => a -> a++A type signature is a complete type signature when there are no+wildcards in the type signature, i.e. iff sig_wcs is empty and+sig_extra_cts is Nothing.+-}++data TcIdSigInst+  = TISI { sig_inst_sig :: TcIdSigInfo++         , sig_inst_skols :: [(Name, TcTyVar)]+               -- Instantiated type and kind variables, TyVarTvs+               -- The Name is the Name that the renamer chose;+               --   but the TcTyVar may come from instantiating+               --   the type and hence have a different unique.+               -- No need to keep track of whether they are truly lexically+               --   scoped because the renamer has named them uniquely+               -- See Note [Binding scoped type variables] in GHC.Tc.Gen.Sig+               --+               -- NB: The order of sig_inst_skols is irrelevant+               --     for a CompleteSig, but for a PartialSig see+               --     Note [Quantified variables in partial type signatures]++         , sig_inst_theta  :: TcThetaType+               -- Instantiated theta.  In the case of a+               -- PartialSig, sig_theta does not include+               -- the extra-constraints wildcard++         , sig_inst_tau :: TcSigmaType   -- Instantiated tau+               -- See Note [sig_inst_tau may be polymorphic]++         -- Relevant for partial signature only+         , sig_inst_wcs   :: [(Name, TcTyVar)]+               -- Like sig_inst_skols, but for /named/ wildcards (_a etc).+               -- The named wildcards scope over the binding, and hence+               -- their Names may appear in type signatures in the binding++         , sig_inst_wcx   :: Maybe TcType+               -- Extra-constraints wildcard to fill in, if any+               -- If this exists, it is surely of the form (meta_tv |> co)+               -- (where the co might be reflexive). This is filled in+               -- only from the return value of GHC.Tc.Gen.HsType.tcAnonWildCardOcc+         }++{- Note [sig_inst_tau may be polymorphic]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Note that "sig_inst_tau" might actually be a polymorphic type,+if the original function had a signature like+   forall a. Eq a => forall b. Ord b => ....+But that's ok: tcMatchesFun (called by tcRhs) can deal with that+It happens, too!  See Note [Polymorphic methods] in GHC.Tc.TyCl.Class.++Note [Quantified variables in partial type signatures]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider+   f :: forall a b. _ -> a -> _ -> b+   f (x,y) p q = q++Then we expect f's final type to be+  f :: forall {x,y}. forall a b. (x,y) -> a -> b -> b++Note that x,y are Inferred, and can't be use for visible type+application (VTA).  But a,b are Specified, and remain Specified+in the final type, so we can use VTA for them.  (Exception: if+it turns out that a's kind mentions b we need to reorder them+with scopedSort.)++The sig_inst_skols of the TISI from a partial signature records+that original order, and is used to get the variables of f's+final type in the correct order.+++Note [Wildcards in partial signatures]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The wildcards in psig_wcs may stand for a type mentioning+the universally-quantified tyvars of psig_ty++E.g.  f :: forall a. _ -> a+      f x = x+We get sig_inst_skols = [a]+       sig_inst_tau   = _22 -> a+       sig_inst_wcs   = [_22]+and _22 in the end is unified with the type 'a'++Moreover the kind of a wildcard in sig_inst_wcs may mention+the universally-quantified tyvars sig_inst_skols+e.g.   f :: t a -> t _+Here we get+   sig_inst_skols = [k:*, (t::k ->*), (a::k)]+   sig_inst_tau   = t a -> t _22+   sig_inst_wcs   = [ _22::k ]+-}++data TcPatSynInfo+  = TPSI {+        patsig_name           :: Name,+        patsig_implicit_bndrs :: [TyVarBinder], -- Implicitly-bound kind vars (Inferred) and+                                                -- implicitly-bound type vars (Specified)+          -- See Note [The pattern-synonym signature splitting rule] in GHC.Tc.TyCl.PatSyn+        patsig_univ_bndrs     :: [TyVar],       -- Bound by explicit user forall+        patsig_req            :: TcThetaType,+        patsig_ex_bndrs       :: [TyVar],       -- Bound by explicit user forall+        patsig_prov           :: TcThetaType,+        patsig_body_ty        :: TcSigmaType+    }++instance Outputable TcSigInfo where+  ppr (TcIdSig     idsi) = ppr idsi+  ppr (TcPatSynSig tpsi) = text "TcPatSynInfo" <+> ppr tpsi++instance Outputable TcIdSigInfo where+    ppr (CompleteSig { sig_bndr = bndr })+        = ppr bndr <+> dcolon <+> ppr (idType bndr)+    ppr (PartialSig { psig_name = name, psig_hs_ty = hs_ty })+        = text "psig" <+> ppr name <+> dcolon <+> ppr hs_ty++instance Outputable TcIdSigInst where+    ppr (TISI { sig_inst_sig = sig, sig_inst_skols = skols+              , sig_inst_theta = theta, sig_inst_tau = tau })+        = hang (ppr sig) 2 (vcat [ ppr skols, ppr theta <+> darrow <+> ppr tau ])++instance Outputable TcPatSynInfo where+    ppr (TPSI{ patsig_name = name}) = ppr name++isPartialSig :: TcIdSigInst -> Bool+isPartialSig (TISI { sig_inst_sig = PartialSig {} }) = True+isPartialSig _                                       = False++-- | No signature or a partial signature+hasCompleteSig :: TcSigFun -> Name -> Bool+hasCompleteSig sig_fn name+  = case sig_fn name of+      Just (TcIdSig (CompleteSig {})) -> True+      _                               -> False+++{-+Constraint Solver Plugins+-------------------------+-}++type TcPluginSolver = [Ct]    -- given+                   -> [Ct]    -- derived+                   -> [Ct]    -- wanted+                   -> TcPluginM TcPluginResult++newtype TcPluginM a = TcPluginM (EvBindsVar -> TcM a) deriving (Functor)++instance Applicative TcPluginM where+  pure x = TcPluginM (const $ pure x)+  (<*>) = ap++instance Monad TcPluginM where+  TcPluginM m >>= k =+    TcPluginM (\ ev -> do a <- m ev+                          runTcPluginM (k a) ev)++instance MonadFail TcPluginM where+  fail x   = TcPluginM (const $ fail x)++runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a+runTcPluginM (TcPluginM m) = m++-- | This function provides an escape for direct access to+-- the 'TcM` monad.  It should not be used lightly, and+-- the provided 'TcPluginM' API should be favoured instead.+unsafeTcPluginTcM :: TcM a -> TcPluginM a+unsafeTcPluginTcM = TcPluginM . const++-- | Access the 'EvBindsVar' carried by the 'TcPluginM' during+-- constraint solving.  Returns 'Nothing' if invoked during+-- 'tcPluginInit' or 'tcPluginStop'.+getEvBindsTcPluginM :: TcPluginM EvBindsVar+getEvBindsTcPluginM = TcPluginM return+++data TcPlugin = forall s. TcPlugin+  { tcPluginInit  :: TcPluginM s+    -- ^ Initialize plugin, when entering type-checker.++  , tcPluginSolve :: s -> TcPluginSolver+    -- ^ Solve some constraints.+    -- TODO: WRITE MORE DETAILS ON HOW THIS WORKS.++  , tcPluginStop  :: s -> TcPluginM ()+   -- ^ Clean up after the plugin, when exiting the type-checker.+  }++data TcPluginResult+  = TcPluginContradiction [Ct]+    -- ^ The plugin found a contradiction.+    -- The returned constraints are removed from the inert set,+    -- and recorded as insoluble.++  | TcPluginOk [(EvTerm,Ct)] [Ct]+    -- ^ The first field is for constraints that were solved.+    -- These are removed from the inert set,+    -- and the evidence for them is recorded.+    -- The second field contains new work, that should be processed by+    -- the constraint solver.++{- *********************************************************************+*                                                                      *+                        Role annotations+*                                                                      *+********************************************************************* -}++type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)++mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv+mkRoleAnnotEnv role_annot_decls+ = mkNameEnv [ (name, ra_decl)+             | ra_decl <- role_annot_decls+             , let name = roleAnnotDeclName (unLoc ra_decl)+             , not (isUnboundName name) ]+       -- Some of the role annots will be unbound;+       -- we don't wish to include these++emptyRoleAnnotEnv :: RoleAnnotEnv+emptyRoleAnnotEnv = emptyNameEnv++lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)+lookupRoleAnnot = lookupNameEnv++getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]+getRoleAnnots bndrs role_env+  = mapMaybe (lookupRoleAnnot role_env) bndrs
+ compiler/GHC/Tc/Types.hs-boot view
@@ -0,0 +1,12 @@+module GHC.Tc.Types where++import GHC.Tc.Utils.TcType+import GHC.Types.SrcLoc++data TcLclEnv++setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv+getLclEnvTcLevel :: TcLclEnv -> TcLevel++setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv+getLclEnvLoc :: TcLclEnv -> RealSrcSpan
+ compiler/GHC/Tc/Types/Constraint.hs view
@@ -0,0 +1,1814 @@+{-# LANGUAGE CPP, GeneralizedNewtypeDeriving #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++-- | This module defines types and simple operations over constraints, as used+-- in the type-checker and constraint solver.+module GHC.Tc.Types.Constraint (+        -- QCInst+        QCInst(..), isPendingScInst,++        -- Canonical constraints+        Xi, Ct(..), Cts, CtIrredStatus(..), emptyCts, andCts, andManyCts, pprCts,+        singleCt, listToCts, ctsElts, consCts, snocCts, extendCtsList,+        isEmptyCts, isCTyEqCan, isCFunEqCan,+        isPendingScDict, superClassesMightHelp, getPendingWantedScs,+        isCDictCan_Maybe, isCFunEqCan_maybe,+        isCNonCanonical, isWantedCt, isDerivedCt,+        isGivenCt, isHoleCt, isOutOfScopeCt, isExprHoleCt, isTypeHoleCt,+        isUserTypeErrorCt, getUserTypeErrorMsg,+        ctEvidence, ctLoc, setCtLoc, ctPred, ctFlavour, ctEqRel, ctOrigin,+        ctEvId, mkTcEqPredLikeEv,+        mkNonCanonical, mkNonCanonicalCt, mkGivens,+        mkIrredCt,+        ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel,+        ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId,+        tyCoVarsOfCt, tyCoVarsOfCts,+        tyCoVarsOfCtList, tyCoVarsOfCtsList,++        WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,+        isSolvedWC, andWC, unionsWC, mkSimpleWC, mkImplicWC,+        addInsols, insolublesOnly, addSimples, addImplics,+        tyCoVarsOfWC, dropDerivedWC, dropDerivedSimples,+        tyCoVarsOfWCList, insolubleCt, insolubleEqCt,+        isDroppableCt, insolubleImplic,+        arisesFromGivens,++        Implication(..), implicationPrototype,+        ImplicStatus(..), isInsolubleStatus, isSolvedStatus,+        SubGoalDepth, initialSubGoalDepth, maxSubGoalDepth,+        bumpSubGoalDepth, subGoalDepthExceeded,+        CtLoc(..), ctLocSpan, ctLocEnv, ctLocLevel, ctLocOrigin,+        ctLocTypeOrKind_maybe,+        ctLocDepth, bumpCtLocDepth, isGivenLoc,+        setCtLocOrigin, updateCtLocOrigin, setCtLocEnv, setCtLocSpan,+        pprCtLoc,++        -- CtEvidence+        CtEvidence(..), TcEvDest(..),+        mkKindLoc, toKindLoc, mkGivenLoc,+        isWanted, isGiven, isDerived, isGivenOrWDeriv,+        ctEvRole,++        wrapType,++        CtFlavour(..), ShadowInfo(..), ctEvFlavour,+        CtFlavourRole, ctEvFlavourRole, ctFlavourRole,+        eqCanRewrite, eqCanRewriteFR, eqMayRewriteFR,+        eqCanDischargeFR,+        funEqCanDischarge, funEqCanDischargeF,++        -- Pretty printing+        pprEvVarTheta,+        pprEvVars, pprEvVarWithType,++        -- holes+        HoleSort(..),++  )+  where++#include "HsVersions.h"++import GHC.Prelude++import {-# SOURCE #-} GHC.Tc.Types ( TcLclEnv, setLclEnvTcLevel, getLclEnvTcLevel+                                   , setLclEnvLoc, getLclEnvLoc )++import GHC.Core.Predicate+import GHC.Core.Type+import GHC.Core.Coercion+import GHC.Core.Class+import GHC.Core.TyCon+import GHC.Types.Var++import GHC.Tc.Utils.TcType+import GHC.Tc.Types.Evidence+import GHC.Tc.Types.Origin++import GHC.Core++import GHC.Core.TyCo.Ppr+import GHC.Types.Name.Occurrence+import GHC.Utils.FV+import GHC.Types.Var.Set+import GHC.Driver.Session+import GHC.Types.Basic++import GHC.Utils.Outputable+import GHC.Types.SrcLoc+import GHC.Data.Bag+import GHC.Utils.Misc++import Control.Monad ( msum )++{-+************************************************************************+*                                                                      *+*                       Canonical constraints                          *+*                                                                      *+*   These are the constraints the low-level simplifier works with      *+*                                                                      *+************************************************************************+-}++-- The syntax of xi (ξ) types:+-- xi ::= a | T xis | xis -> xis | ... | forall a. tau+-- Two important notes:+--      (i) No type families, unless we are under a ForAll+--      (ii) Note that xi types can contain unexpanded type synonyms;+--           however, the (transitive) expansions of those type synonyms+--           will not contain any type functions, unless we are under a ForAll.+-- We enforce the structure of Xi types when we flatten (GHC.Tc.Solver.Canonical)++type Xi = Type       -- In many comments, "xi" ranges over Xi++type Cts = Bag Ct++data Ct+  -- Atomic canonical constraints+  = CDictCan {  -- e.g.  Num xi+      cc_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]++      cc_class  :: Class,+      cc_tyargs :: [Xi],   -- cc_tyargs are function-free, hence Xi++      cc_pend_sc :: Bool   -- See Note [The superclass story] in GHC.Tc.Solver.Canonical+                           -- True <=> (a) cc_class has superclasses+                           --          (b) we have not (yet) added those+                           --              superclasses as Givens+    }++  | CIrredCan {  -- These stand for yet-unusable predicates+      cc_ev     :: CtEvidence,   -- See Note [Ct/evidence invariant]+      cc_status :: CtIrredStatus++        -- For the might-be-soluble case, the ctev_pred of the evidence is+        -- of form   (tv xi1 xi2 ... xin)   with a tyvar at the head+        --      or   (tv1 ~ ty2)   where the CTyEqCan  kind invariant (TyEq:K) fails+        --      or   (F tys ~ ty)  where the CFunEqCan kind invariant fails+        -- See Note [CIrredCan constraints]++        -- The definitely-insoluble case is for things like+        --    Int ~ Bool      tycons don't match+        --    a ~ [a]         occurs check+    }++  | CTyEqCan {  -- tv ~ rhs+       -- Invariants:+       --   * See Note [inert_eqs: the inert equalities] in GHC.Tc.Solver.Monad+       --   * (TyEq:OC) tv not in deep tvs(rhs)   (occurs check)+       --   * (TyEq:F) If tv is a TauTv, then rhs has no foralls+       --       (this avoids substituting a forall for the tyvar in other types)+       --   * (TyEq:K) tcTypeKind ty `tcEqKind` tcTypeKind tv; Note [Ct kind invariant]+       --   * (TyEq:AFF) rhs (perhaps under the one cast) is *almost function-free*,+       --       See Note [Almost function-free]+       --   * (TyEq:N) If the equality is representational, rhs has no top-level newtype+       --     See Note [No top-level newtypes on RHS of representational+       --     equalities] in GHC.Tc.Solver.Canonical+       --   * (TyEq:TV) If rhs (perhaps under the cast) is also a tv, then it is oriented+       --     to give best chance of+       --     unification happening; eg if rhs is touchable then lhs is too+       --     See TcCanonical Note [Canonical orientation for tyvar/tyvar equality constraints]+       --   * (TyEq:H) The RHS has no blocking coercion holes. See TcCanonical+       --     Note [Equalities with incompatible kinds], wrinkle (2)+      cc_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]+      cc_tyvar  :: TcTyVar,+      cc_rhs    :: TcType,     -- Not necessarily function-free (hence not Xi)+                               -- See invariants above++      cc_eq_rel :: EqRel       -- INVARIANT: cc_eq_rel = ctEvEqRel cc_ev+    }++  | CFunEqCan {  -- F xis ~ fsk+       -- Invariants:+       --   * isTypeFamilyTyCon cc_fun+       --   * tcTypeKind (F xis) = tyVarKind fsk; Note [Ct kind invariant]+       --   * always Nominal role+      cc_ev     :: CtEvidence,  -- See Note [Ct/evidence invariant]+      cc_fun    :: TyCon,       -- A type function++      cc_tyargs :: [Xi],        -- cc_tyargs are function-free (hence Xi)+        -- Either under-saturated or exactly saturated+        --    *never* over-saturated (because if so+        --    we should have decomposed)++      cc_fsk    :: TcTyVar  -- [G]  always a FlatSkolTv+                            -- [W], [WD], or [D] always a FlatMetaTv+        -- See Note [The flattening story] in GHC.Tc.Solver.Flatten+    }++  | CNonCanonical {        -- See Note [NonCanonical Semantics] in GHC.Tc.Solver.Monad+      cc_ev  :: CtEvidence+    }++  | CHoleCan {             -- See Note [Hole constraints]+       -- Treated as an "insoluble" constraint+       -- See Note [Insoluble constraints]+      cc_ev   :: CtEvidence,+      cc_occ  :: OccName,   -- The name of this hole+      cc_hole :: HoleSort   -- The sort of this hole (expr, type, ...)+    }++  | CQuantCan QCInst       -- A quantified constraint+      -- NB: I expect to make more of the cases in Ct+      --     look like this, with the payload in an+      --     auxiliary type++------------+data QCInst  -- A much simplified version of ClsInst+             -- See Note [Quantified constraints] in GHC.Tc.Solver.Canonical+  = QCI { qci_ev   :: CtEvidence -- Always of type forall tvs. context => ty+                                 -- Always Given+        , qci_tvs  :: [TcTyVar]  -- The tvs+        , qci_pred :: TcPredType -- The ty+        , qci_pend_sc :: Bool    -- Same as cc_pend_sc flag in CDictCan+                                 -- Invariant: True => qci_pred is a ClassPred+    }++instance Outputable QCInst where+  ppr (QCI { qci_ev = ev }) = ppr ev++------------+-- | Used to indicate which sort of hole we have.+data HoleSort = ExprHole+                 -- ^ Either an out-of-scope variable or a "true" hole in an+                 -- expression (TypedHoles)+              | TypeHole+                 -- ^ A hole in a type (PartialTypeSignatures)++------------+-- | Used to indicate extra information about why a CIrredCan is irreducible+data CtIrredStatus+  = InsolubleCIS   -- this constraint will never be solved+  | BlockedCIS     -- this constraint is blocked on a coercion hole+                   -- The hole will appear in the ctEvPred of the constraint with this status+                   -- See Note [Equalities with incompatible kinds] in TcCanonical+                   -- Wrinkle (4a)+  | OtherCIS++instance Outputable CtIrredStatus where+  ppr InsolubleCIS = text "(insoluble)"+  ppr BlockedCIS   = text "(blocked)"+  ppr OtherCIS     = text "(soluble)"++{- Note [Hole constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~+CHoleCan constraints are used for two kinds of holes,+distinguished by cc_hole:++  * For holes in expressions+    e.g.   f x = g _ x++  * For holes in type signatures+    e.g.   f :: _ -> _+           f x = [x,True]++Note [CIrredCan constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+CIrredCan constraints are used for constraints that are "stuck"+   - we can't solve them (yet)+   - we can't use them to solve other constraints+   - but they may become soluble if we substitute for some+     of the type variables in the constraint++Example 1:  (c Int), where c :: * -> Constraint.  We can't do anything+            with this yet, but if later c := Num, *then* we can solve it++Example 2:  a ~ b, where a :: *, b :: k, where k is a kind variable+            We don't want to use this to substitute 'b' for 'a', in case+            'k' is subsequently unified with (say) *->*, because then+            we'd have ill-kinded types floating about.  Rather we want+            to defer using the equality altogether until 'k' get resolved.++Note [Ct/evidence invariant]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+If  ct :: Ct, then extra fields of 'ct' cache precisely the ctev_pred field+of (cc_ev ct), and is fully rewritten wrt the substitution.   Eg for CDictCan,+   ctev_pred (cc_ev ct) = (cc_class ct) (cc_tyargs ct)+This holds by construction; look at the unique place where CDictCan is+built (in GHC.Tc.Solver.Canonical).++In contrast, the type of the evidence *term* (ctev_dest / ctev_evar) in+the evidence may *not* be fully zonked; we are careful not to look at it+during constraint solving. See Note [Evidence field of CtEvidence].++Note [Ct kind invariant]+~~~~~~~~~~~~~~~~~~~~~~~~+CTyEqCan and CFunEqCan both require that the kind of the lhs matches the kind+of the rhs. This is necessary because both constraints are used for substitutions+during solving. If the kinds differed, then the substitution would take a well-kinded+type to an ill-kinded one.++Note [Almost function-free]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+A type is *almost function-free* if it has no type functions (something that+responds True to isTypeFamilyTyCon), except (possibly)+ * under a forall, or+ * in a coercion (either in a CastTy or a CercionTy)++The RHS of a CTyEqCan must be almost function-free, invariant (TyEq:AFF).+This is for two reasons:++1. There cannot be a top-level function. If there were, the equality should+   really be a CFunEqCan, not a CTyEqCan.++2. Nested functions aren't too bad, on the other hand. However, consider this+   scenario:++     type family F a = r | r -> a++     [D] F ty1 ~ fsk1+     [D] F ty2 ~ fsk2+     [D] fsk1 ~ [G Int]+     [D] fsk2 ~ [G Bool]++     type instance G Int = Char+     type instance G Bool = Char++   If it was the case that fsk1 = fsk2, then we could unifty ty1 and ty2 --+   good! They don't look equal -- but if we aggressively reduce that G Int and+   G Bool they would become equal. The "almost function free" makes sure that+   these redexes are exposed.++   Note that this equality does *not* depend on casts or coercions, and so+   skipping these forms is OK. In addition, the result of a type family cannot+   be a polytype, so skipping foralls is OK, too. We skip foralls because we+   want the output of the flattener to be almost function-free. See Note+   [Flattening under a forall] in GHC.Tc.Solver.Flatten.++   As I (Richard E) write this, it is unclear if the scenario pictured above+   can happen -- I would expect the G Int and G Bool to be reduced. But+   perhaps it can arise somehow, and maintaining almost function-free is cheap.++Historical note: CTyEqCans used to require only condition (1) above: that no+type family was at the top of an RHS. But work on #16512 suggested that the+injectivity checks were not complete, and adding the requirement that functions+do not appear even in a nested fashion was easy (it was already true, but+unenforced).++The almost-function-free property is checked by isAlmostFunctionFree in GHC.Tc.Utils.TcType.+The flattener (in GHC.Tc.Solver.Flatten) produces types that are almost function-free.++-}++mkNonCanonical :: CtEvidence -> Ct+mkNonCanonical ev = CNonCanonical { cc_ev = ev }++mkNonCanonicalCt :: Ct -> Ct+mkNonCanonicalCt ct = CNonCanonical { cc_ev = cc_ev ct }++mkIrredCt :: CtIrredStatus -> CtEvidence -> Ct+mkIrredCt status ev = CIrredCan { cc_ev = ev, cc_status = status }++mkGivens :: CtLoc -> [EvId] -> [Ct]+mkGivens loc ev_ids+  = map mk ev_ids+  where+    mk ev_id = mkNonCanonical (CtGiven { ctev_evar = ev_id+                                       , ctev_pred = evVarPred ev_id+                                       , ctev_loc = loc })++ctEvidence :: Ct -> CtEvidence+ctEvidence (CQuantCan (QCI { qci_ev = ev })) = ev+ctEvidence ct = cc_ev ct++ctLoc :: Ct -> CtLoc+ctLoc = ctEvLoc . ctEvidence++setCtLoc :: Ct -> CtLoc -> Ct+setCtLoc ct loc = ct { cc_ev = (cc_ev ct) { ctev_loc = loc } }++ctOrigin :: Ct -> CtOrigin+ctOrigin = ctLocOrigin . ctLoc++ctPred :: Ct -> PredType+-- See Note [Ct/evidence invariant]+ctPred ct = ctEvPred (ctEvidence ct)++ctEvId :: Ct -> EvVar+-- The evidence Id for this Ct+ctEvId ct = ctEvEvId (ctEvidence ct)++-- | Makes a new equality predicate with the same role as the given+-- evidence.+mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType+mkTcEqPredLikeEv ev+  = case predTypeEqRel pred of+      NomEq  -> mkPrimEqPred+      ReprEq -> mkReprPrimEqPred+  where+    pred = ctEvPred ev++-- | Get the flavour of the given 'Ct'+ctFlavour :: Ct -> CtFlavour+ctFlavour = ctEvFlavour . ctEvidence++-- | Get the equality relation for the given 'Ct'+ctEqRel :: Ct -> EqRel+ctEqRel = ctEvEqRel . ctEvidence++instance Outputable Ct where+  ppr ct = ppr (ctEvidence ct) <+> parens pp_sort+    where+      pp_sort = case ct of+         CTyEqCan {}      -> text "CTyEqCan"+         CFunEqCan {}     -> text "CFunEqCan"+         CNonCanonical {} -> text "CNonCanonical"+         CDictCan { cc_pend_sc = pend_sc }+            | pend_sc   -> text "CDictCan(psc)"+            | otherwise -> text "CDictCan"+         CIrredCan { cc_status = status } -> text "CIrredCan" <> ppr status+         CHoleCan { cc_occ = occ } -> text "CHoleCan:" <+> ppr occ+         CQuantCan (QCI { qci_pend_sc = pend_sc })+            | pend_sc   -> text "CQuantCan(psc)"+            | otherwise -> text "CQuantCan"++{-+************************************************************************+*                                                                      *+        Simple functions over evidence variables+*                                                                      *+************************************************************************+-}++---------------- Getting free tyvars -------------------------++-- | Returns free variables of constraints as a non-deterministic set+tyCoVarsOfCt :: Ct -> TcTyCoVarSet+tyCoVarsOfCt = fvVarSet . tyCoFVsOfCt++-- | Returns free variables of constraints as a deterministically ordered.+-- list. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoVarsOfCtList :: Ct -> [TcTyCoVar]+tyCoVarsOfCtList = fvVarList . tyCoFVsOfCt++-- | Returns free variables of constraints as a composable FV computation.+-- See Note [Deterministic FV] in GHC.Utils.FV.+tyCoFVsOfCt :: Ct -> FV+tyCoFVsOfCt ct = tyCoFVsOfType (ctPred ct)+  -- This must consult only the ctPred, so that it gets *tidied* fvs if the+  -- constraint has been tidied. Tidying a constraint does not tidy the+  -- fields of the Ct, only the predicate in the CtEvidence.++-- | Returns free variables of a bag of constraints as a non-deterministic+-- set. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoVarsOfCts :: Cts -> TcTyCoVarSet+tyCoVarsOfCts = fvVarSet . tyCoFVsOfCts++-- | Returns free variables of a bag of constraints as a deterministically+-- ordered list. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]+tyCoVarsOfCtsList = fvVarList . tyCoFVsOfCts++-- | Returns free variables of a bag of constraints as a composable FV+-- computation. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoFVsOfCts :: Cts -> FV+tyCoFVsOfCts = foldr (unionFV . tyCoFVsOfCt) emptyFV++-- | Returns free variables of WantedConstraints as a non-deterministic+-- set. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet+-- Only called on *zonked* things, hence no need to worry about flatten-skolems+tyCoVarsOfWC = fvVarSet . tyCoFVsOfWC++-- | Returns free variables of WantedConstraints as a deterministically+-- ordered list. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]+-- Only called on *zonked* things, hence no need to worry about flatten-skolems+tyCoVarsOfWCList = fvVarList . tyCoFVsOfWC++-- | Returns free variables of WantedConstraints as a composable FV+-- computation. See Note [Deterministic FV] in GHC.Utils.FV.+tyCoFVsOfWC :: WantedConstraints -> FV+-- Only called on *zonked* things, hence no need to worry about flatten-skolems+tyCoFVsOfWC (WC { wc_simple = simple, wc_impl = implic })+  = tyCoFVsOfCts simple `unionFV`+    tyCoFVsOfBag tyCoFVsOfImplic implic++-- | Returns free variables of Implication as a composable FV computation.+-- See Note [Deterministic FV] in GHC.Utils.FV.+tyCoFVsOfImplic :: Implication -> FV+-- Only called on *zonked* things, hence no need to worry about flatten-skolems+tyCoFVsOfImplic (Implic { ic_skols = skols+                        , ic_given = givens+                        , ic_wanted = wanted })+  | isEmptyWC wanted+  = emptyFV+  | otherwise+  = tyCoFVsVarBndrs skols  $+    tyCoFVsVarBndrs givens $+    tyCoFVsOfWC wanted++tyCoFVsOfBag :: (a -> FV) -> Bag a -> FV+tyCoFVsOfBag tvs_of = foldr (unionFV . tvs_of) emptyFV++---------------------------+dropDerivedWC :: WantedConstraints -> WantedConstraints+-- See Note [Dropping derived constraints]+dropDerivedWC wc@(WC { wc_simple = simples })+  = wc { wc_simple = dropDerivedSimples simples }+    -- The wc_impl implications are already (recursively) filtered++--------------------------+dropDerivedSimples :: Cts -> Cts+-- Drop all Derived constraints, but make [W] back into [WD],+-- so that if we re-simplify these constraints we will get all+-- the right derived constraints re-generated.  Forgetting this+-- step led to #12936+dropDerivedSimples simples = mapMaybeBag dropDerivedCt simples++dropDerivedCt :: Ct -> Maybe Ct+dropDerivedCt ct+  = case ctEvFlavour ev of+      Wanted WOnly -> Just (ct' { cc_ev = ev_wd })+      Wanted _     -> Just ct'+      _ | isDroppableCt ct -> Nothing+        | otherwise        -> Just ct+  where+    ev    = ctEvidence ct+    ev_wd = ev { ctev_nosh = WDeriv }+    ct'   = setPendingScDict ct -- See Note [Resetting cc_pend_sc]++{- Note [Resetting cc_pend_sc]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we discard Derived constraints, in dropDerivedSimples, we must+set the cc_pend_sc flag to True, so that if we re-process this+CDictCan we will re-generate its derived superclasses. Otherwise+we might miss some fundeps.  #13662 showed this up.++See Note [The superclass story] in GHC.Tc.Solver.Canonical.+-}++isDroppableCt :: Ct -> Bool+isDroppableCt ct+  = isDerived ev && not keep_deriv+    -- Drop only derived constraints, and then only if they+    -- obey Note [Dropping derived constraints]+  where+    ev   = ctEvidence ct+    loc  = ctEvLoc ev+    orig = ctLocOrigin loc++    keep_deriv+      = case ct of+          CHoleCan {}                            -> True+          CIrredCan { cc_status = InsolubleCIS } -> keep_eq True+          _                                      -> keep_eq False++    keep_eq definitely_insoluble+       | isGivenOrigin orig    -- Arising only from givens+       = definitely_insoluble  -- Keep only definitely insoluble+       | otherwise+       = case orig of+           -- See Note [Dropping derived constraints]+           -- For fundeps, drop wanted/wanted interactions+           FunDepOrigin2 {} -> True   -- Top-level/Wanted+           FunDepOrigin1 _ orig1 _ _ orig2 _+             | g1 || g2  -> True  -- Given/Wanted errors: keep all+             | otherwise -> False -- Wanted/Wanted errors: discard+             where+               g1 = isGivenOrigin orig1+               g2 = isGivenOrigin orig2++           _ -> False++arisesFromGivens :: Ct -> Bool+arisesFromGivens ct+  = case ctEvidence ct of+      CtGiven {}                   -> True+      CtWanted {}                  -> False+      CtDerived { ctev_loc = loc } -> isGivenLoc loc++isGivenLoc :: CtLoc -> Bool+isGivenLoc loc = isGivenOrigin (ctLocOrigin loc)++{- Note [Dropping derived constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+In general we discard derived constraints at the end of constraint solving;+see dropDerivedWC.  For example++ * Superclasses: if we have an unsolved [W] (Ord a), we don't want to+   complain about an unsolved [D] (Eq a) as well.++ * If we have [W] a ~ Int, [W] a ~ Bool, improvement will generate+   [D] Int ~ Bool, and we don't want to report that because it's+   incomprehensible. That is why we don't rewrite wanteds with wanteds!++ * We might float out some Wanteds from an implication, leaving behind+   their insoluble Deriveds. For example:++   forall a[2]. [W] alpha[1] ~ Int+                [W] alpha[1] ~ Bool+                [D] Int ~ Bool++   The Derived is insoluble, but we very much want to drop it when floating+   out.++But (tiresomely) we do keep *some* Derived constraints:++ * Type holes are derived constraints, because they have no evidence+   and we want to keep them, so we get the error report++ * We keep most derived equalities arising from functional dependencies+      - Given/Given interactions (subset of FunDepOrigin1):+        The definitely-insoluble ones reflect unreachable code.++        Others not-definitely-insoluble ones like [D] a ~ Int do not+        reflect unreachable code; indeed if fundeps generated proofs, it'd+        be a useful equality.  See #14763.   So we discard them.++      - Given/Wanted interacGiven or Wanted interacting with an+        instance declaration (FunDepOrigin2)++      - Given/Wanted interactions (FunDepOrigin1); see #9612++      - But for Wanted/Wanted interactions we do /not/ want to report an+        error (#13506).  Consider [W] C Int Int, [W] C Int Bool, with+        a fundep on class C.  We don't want to report an insoluble Int~Bool;+        c.f. "wanteds do not rewrite wanteds".++To distinguish these cases we use the CtOrigin.++NB: we keep *all* derived insolubles under some circumstances:++  * They are looked at by simplifyInfer, to decide whether to+    generalise.  Example: [W] a ~ Int, [W] a ~ Bool+    We get [D] Int ~ Bool, and indeed the constraints are insoluble,+    and we want simplifyInfer to see that, even though we don't+    ultimately want to generate an (inexplicable) error message from it+++************************************************************************+*                                                                      *+                    CtEvidence+         The "flavor" of a canonical constraint+*                                                                      *+************************************************************************+-}++isWantedCt :: Ct -> Bool+isWantedCt = isWanted . ctEvidence++isGivenCt :: Ct -> Bool+isGivenCt = isGiven . ctEvidence++isDerivedCt :: Ct -> Bool+isDerivedCt = isDerived . ctEvidence++isCTyEqCan :: Ct -> Bool+isCTyEqCan (CTyEqCan {})  = True+isCTyEqCan _              = False++isCDictCan_Maybe :: Ct -> Maybe Class+isCDictCan_Maybe (CDictCan {cc_class = cls })  = Just cls+isCDictCan_Maybe _              = Nothing++isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type])+isCFunEqCan_maybe (CFunEqCan { cc_fun = tc, cc_tyargs = xis }) = Just (tc, xis)+isCFunEqCan_maybe _ = Nothing++isCFunEqCan :: Ct -> Bool+isCFunEqCan (CFunEqCan {}) = True+isCFunEqCan _ = False++isCNonCanonical :: Ct -> Bool+isCNonCanonical (CNonCanonical {}) = True+isCNonCanonical _ = False++isHoleCt:: Ct -> Bool+isHoleCt (CHoleCan {}) = True+isHoleCt _ = False++isOutOfScopeCt :: Ct -> Bool+-- A Hole that does not have a leading underscore is+-- simply an out-of-scope variable, and we treat that+-- a bit differently when it comes to error reporting+isOutOfScopeCt (CHoleCan { cc_occ = occ }) = not (startsWithUnderscore occ)+isOutOfScopeCt _ = False++isExprHoleCt :: Ct -> Bool+isExprHoleCt (CHoleCan { cc_hole = ExprHole }) = True+isExprHoleCt _ = False++isTypeHoleCt :: Ct -> Bool+isTypeHoleCt (CHoleCan { cc_hole = TypeHole }) = True+isTypeHoleCt _ = False+++{- Note [Custom type errors in constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++When GHC reports a type-error about an unsolved-constraint, we check+to see if the constraint contains any custom-type errors, and if so+we report them.  Here are some examples of constraints containing type+errors:++TypeError msg           -- The actual constraint is a type error++TypError msg ~ Int      -- Some type was supposed to be Int, but ended up+                        -- being a type error instead++Eq (TypeError msg)      -- A class constraint is stuck due to a type error++F (TypeError msg) ~ a   -- A type function failed to evaluate due to a type err++It is also possible to have constraints where the type error is nested deeper,+for example see #11990, and also:++Eq (F (TypeError msg))  -- Here the type error is nested under a type-function+                        -- call, which failed to evaluate because of it,+                        -- and so the `Eq` constraint was unsolved.+                        -- This may happen when one function calls another+                        -- and the called function produced a custom type error.+-}++-- | A constraint is considered to be a custom type error, if it contains+-- custom type errors anywhere in it.+-- See Note [Custom type errors in constraints]+getUserTypeErrorMsg :: Ct -> Maybe Type+getUserTypeErrorMsg ct = findUserTypeError (ctPred ct)+  where+  findUserTypeError t = msum ( userTypeError_maybe t+                             : map findUserTypeError (subTys t)+                             )++  subTys t            = case splitAppTys t of+                          (t,[]) ->+                            case splitTyConApp_maybe t of+                              Nothing     -> []+                              Just (_,ts) -> ts+                          (t,ts) -> t : ts+++++isUserTypeErrorCt :: Ct -> Bool+isUserTypeErrorCt ct = case getUserTypeErrorMsg ct of+                         Just _ -> True+                         _      -> False++isPendingScDict :: Ct -> Maybe Ct+-- Says whether this is a CDictCan with cc_pend_sc is True,+-- AND if so flips the flag+isPendingScDict ct@(CDictCan { cc_pend_sc = True })+                  = Just (ct { cc_pend_sc = False })+isPendingScDict _ = Nothing++isPendingScInst :: QCInst -> Maybe QCInst+-- Same as isPendingScDict, but for QCInsts+isPendingScInst qci@(QCI { qci_pend_sc = True })+                  = Just (qci { qci_pend_sc = False })+isPendingScInst _ = Nothing++setPendingScDict :: Ct -> Ct+-- Set the cc_pend_sc flag to True+setPendingScDict ct@(CDictCan { cc_pend_sc = False })+                    = ct { cc_pend_sc = True }+setPendingScDict ct = ct++superClassesMightHelp :: WantedConstraints -> Bool+-- ^ True if taking superclasses of givens, or of wanteds (to perhaps+-- expose more equalities or functional dependencies) might help to+-- solve this constraint.  See Note [When superclasses help]+superClassesMightHelp (WC { wc_simple = simples, wc_impl = implics })+  = anyBag might_help_ct simples || anyBag might_help_implic implics+  where+    might_help_implic ic+       | IC_Unsolved <- ic_status ic = superClassesMightHelp (ic_wanted ic)+       | otherwise                   = False++    might_help_ct ct = isWantedCt ct && not (is_ip ct)++    is_ip (CDictCan { cc_class = cls }) = isIPClass cls+    is_ip _                             = False++getPendingWantedScs :: Cts -> ([Ct], Cts)+getPendingWantedScs simples+  = mapAccumBagL get [] simples+  where+    get acc ct | Just ct' <- isPendingScDict ct+               = (ct':acc, ct')+               | otherwise+               = (acc,     ct)++{- Note [When superclasses help]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+First read Note [The superclass story] in GHC.Tc.Solver.Canonical.++We expand superclasses and iterate only if there is at unsolved wanted+for which expansion of superclasses (e.g. from given constraints)+might actually help. The function superClassesMightHelp tells if+doing this superclass expansion might help solve this constraint.+Note that++  * We look inside implications; maybe it'll help to expand the Givens+    at level 2 to help solve an unsolved Wanted buried inside an+    implication.  E.g.+        forall a. Ord a => forall b. [W] Eq a++  * Superclasses help only for Wanted constraints.  Derived constraints+    are not really "unsolved" and we certainly don't want them to+    trigger superclass expansion. This was a good part of the loop+    in  #11523++  * Even for Wanted constraints, we say "no" for implicit parameters.+    we have [W] ?x::ty, expanding superclasses won't help:+      - Superclasses can't be implicit parameters+      - If we have a [G] ?x:ty2, then we'll have another unsolved+        [D] ty ~ ty2 (from the functional dependency)+        which will trigger superclass expansion.++    It's a bit of a special case, but it's easy to do.  The runtime cost+    is low because the unsolved set is usually empty anyway (errors+    aside), and the first non-implicit-parameter will terminate the search.++    The special case is worth it (#11480, comment:2) because it+    applies to CallStack constraints, which aren't type errors. If we have+       f :: (C a) => blah+       f x = ...undefined...+    we'll get a CallStack constraint.  If that's the only unsolved+    constraint it'll eventually be solved by defaulting.  So we don't+    want to emit warnings about hitting the simplifier's iteration+    limit.  A CallStack constraint really isn't an unsolved+    constraint; it can always be solved by defaulting.+-}++singleCt :: Ct -> Cts+singleCt = unitBag++andCts :: Cts -> Cts -> Cts+andCts = unionBags++listToCts :: [Ct] -> Cts+listToCts = listToBag++ctsElts :: Cts -> [Ct]+ctsElts = bagToList++consCts :: Ct -> Cts -> Cts+consCts = consBag++snocCts :: Cts -> Ct -> Cts+snocCts = snocBag++extendCtsList :: Cts -> [Ct] -> Cts+extendCtsList cts xs | null xs   = cts+                     | otherwise = cts `unionBags` listToBag xs++andManyCts :: [Cts] -> Cts+andManyCts = unionManyBags++emptyCts :: Cts+emptyCts = emptyBag++isEmptyCts :: Cts -> Bool+isEmptyCts = isEmptyBag++pprCts :: Cts -> SDoc+pprCts cts = vcat (map ppr (bagToList cts))++{-+************************************************************************+*                                                                      *+                Wanted constraints+     These are forced to be in GHC.Tc.Types because+           TcLclEnv mentions WantedConstraints+           WantedConstraint mentions CtLoc+           CtLoc mentions ErrCtxt+           ErrCtxt mentions TcM+*                                                                      *+v%************************************************************************+-}++data WantedConstraints+  = WC { wc_simple :: Cts              -- Unsolved constraints, all wanted+       , wc_impl   :: Bag Implication+    }++emptyWC :: WantedConstraints+emptyWC = WC { wc_simple = emptyBag, wc_impl = emptyBag }++mkSimpleWC :: [CtEvidence] -> WantedConstraints+mkSimpleWC cts+  = WC { wc_simple = listToBag (map mkNonCanonical cts)+       , wc_impl = emptyBag }++mkImplicWC :: Bag Implication -> WantedConstraints+mkImplicWC implic+  = WC { wc_simple = emptyBag, wc_impl = implic }++isEmptyWC :: WantedConstraints -> Bool+isEmptyWC (WC { wc_simple = f, wc_impl = i })+  = isEmptyBag f && isEmptyBag i+++-- | Checks whether a the given wanted constraints are solved, i.e.+-- that there are no simple constraints left and all the implications+-- are solved.+isSolvedWC :: WantedConstraints -> Bool+isSolvedWC WC {wc_simple = wc_simple, wc_impl = wc_impl} =+  isEmptyBag wc_simple && allBag (isSolvedStatus . ic_status) wc_impl++andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints+andWC (WC { wc_simple = f1, wc_impl = i1 })+      (WC { wc_simple = f2, wc_impl = i2 })+  = WC { wc_simple = f1 `unionBags` f2+       , wc_impl   = i1 `unionBags` i2 }++unionsWC :: [WantedConstraints] -> WantedConstraints+unionsWC = foldr andWC emptyWC++addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints+addSimples wc cts+  = wc { wc_simple = wc_simple wc `unionBags` cts }+    -- Consider: Put the new constraints at the front, so they get solved first++addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints+addImplics wc implic = wc { wc_impl = wc_impl wc `unionBags` implic }++addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints+addInsols wc cts+  = wc { wc_simple = wc_simple wc `unionBags` cts }++insolublesOnly :: WantedConstraints -> WantedConstraints+-- Keep only the definitely-insoluble constraints+insolublesOnly (WC { wc_simple = simples, wc_impl = implics })+  = WC { wc_simple = filterBag insolubleCt simples+       , wc_impl   = mapBag implic_insols_only implics }+  where+    implic_insols_only implic+      = implic { ic_wanted = insolublesOnly (ic_wanted implic) }++isSolvedStatus :: ImplicStatus -> Bool+isSolvedStatus (IC_Solved {}) = True+isSolvedStatus _              = False++isInsolubleStatus :: ImplicStatus -> Bool+isInsolubleStatus IC_Insoluble    = True+isInsolubleStatus IC_BadTelescope = True+isInsolubleStatus _               = False++insolubleImplic :: Implication -> Bool+insolubleImplic ic = isInsolubleStatus (ic_status ic)++insolubleWC :: WantedConstraints -> Bool+insolubleWC (WC { wc_impl = implics, wc_simple = simples })+  =  anyBag insolubleCt simples+  || anyBag insolubleImplic implics++insolubleCt :: Ct -> Bool+-- Definitely insoluble, in particular /excluding/ type-hole constraints+-- Namely: a) an equality constraint+--         b) that is insoluble+--         c) and does not arise from a Given+insolubleCt ct+  | isHoleCt ct            = isOutOfScopeCt ct  -- See Note [Insoluble holes]+  | not (insolubleEqCt ct) = False+  | arisesFromGivens ct    = False              -- See Note [Given insolubles]+  | otherwise              = True++insolubleEqCt :: Ct -> Bool+-- Returns True of /equality/ constraints+-- that are /definitely/ insoluble+-- It won't detect some definite errors like+--       F a ~ T (F a)+-- where F is a type family, which actually has an occurs check+--+-- The function is tuned for application /after/ constraint solving+--       i.e. assuming canonicalisation has been done+-- E.g.  It'll reply True  for     a ~ [a]+--               but False for   [a] ~ a+-- and+--                   True for  Int ~ F a Int+--               but False for  Maybe Int ~ F a Int Int+--               (where F is an arity-1 type function)+insolubleEqCt (CIrredCan { cc_status = InsolubleCIS }) = True+insolubleEqCt _                                        = False++instance Outputable WantedConstraints where+  ppr (WC {wc_simple = s, wc_impl = i})+   = text "WC" <+> braces (vcat+        [ ppr_bag (text "wc_simple") s+        , ppr_bag (text "wc_impl") i ])++ppr_bag :: Outputable a => SDoc -> Bag a -> SDoc+ppr_bag doc bag+ | isEmptyBag bag = empty+ | otherwise      = hang (doc <+> equals)+                       2 (foldr (($$) . ppr) empty bag)++{- Note [Given insolubles]+~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider (#14325, comment:)+    class (a~b) => C a b++    foo :: C a c => a -> c+    foo x = x++    hm3 :: C (f b) b => b -> f b+    hm3 x = foo x++In the RHS of hm3, from the [G] C (f b) b we get the insoluble+[G] f b ~# b.  Then we also get an unsolved [W] C b (f b).+Residual implication looks like+    forall b. C (f b) b => [G] f b ~# b+                           [W] C f (f b)++We do /not/ want to set the implication status to IC_Insoluble,+because that'll suppress reports of [W] C b (f b).  But we+may not report the insoluble [G] f b ~# b either (see Note [Given errors]+in GHC.Tc.Errors), so we may fail to report anything at all!  Yikes.++The same applies to Derived constraints that /arise from/ Givens.+E.g.   f :: (C Int [a]) => blah+where a fundep means we get+       [D] Int ~ [a]+By the same reasoning we must not suppress other errors (#15767)++Bottom line: insolubleWC (called in GHC.Tc.Solver.setImplicationStatus)+             should ignore givens even if they are insoluble.++Note [Insoluble holes]+~~~~~~~~~~~~~~~~~~~~~~+Hole constraints that ARE NOT treated as truly insoluble:+  a) type holes, arising from PartialTypeSignatures,+  b) "true" expression holes arising from TypedHoles++An "expression hole" or "type hole" constraint isn't really an error+at all; it's a report saying "_ :: Int" here.  But an out-of-scope+variable masquerading as expression holes IS treated as truly+insoluble, so that it trumps other errors during error reporting.+Yuk!++************************************************************************+*                                                                      *+                Implication constraints+*                                                                      *+************************************************************************+-}++data Implication+  = Implic {   -- Invariants for a tree of implications:+               -- see TcType Note [TcLevel and untouchable type variables]++      ic_tclvl :: TcLevel,       -- TcLevel of unification variables+                                 -- allocated /inside/ this implication++      ic_skols :: [TcTyVar],     -- Introduced skolems+      ic_info  :: SkolemInfo,    -- See Note [Skolems in an implication]+                                 -- See Note [Shadowing in a constraint]++      ic_telescope :: Maybe SDoc,  -- User-written telescope, if there is one+                                   -- See Note [Checking telescopes]++      ic_given  :: [EvVar],      -- Given evidence variables+                                 --   (order does not matter)+                                 -- See Invariant (GivenInv) in GHC.Tc.Utils.TcType++      ic_no_eqs :: Bool,         -- True  <=> ic_givens have no equalities, for sure+                                 -- False <=> ic_givens might have equalities++      ic_warn_inaccessible :: Bool,+                                 -- True  <=> -Winaccessible-code is enabled+                                 -- at construction. See+                                 -- Note [Avoid -Winaccessible-code when deriving]+                                 -- in GHC.Tc.TyCl.Instance++      ic_env   :: TcLclEnv,+                                 -- Records the TcLClEnv at the time of creation.+                                 --+                                 -- The TcLclEnv gives the source location+                                 -- and error context for the implication, and+                                 -- hence for all the given evidence variables.++      ic_wanted :: WantedConstraints,  -- The wanteds+                                       -- See Invariang (WantedInf) in GHC.Tc.Utils.TcType++      ic_binds  :: EvBindsVar,    -- Points to the place to fill in the+                                  -- abstraction and bindings.++      -- The ic_need fields keep track of which Given evidence+      -- is used by this implication or its children+      -- NB: including stuff used by nested implications that have since+      --     been discarded+      -- See Note [Needed evidence variables]+      ic_need_inner :: VarSet,    -- Includes all used Given evidence+      ic_need_outer :: VarSet,    -- Includes only the free Given evidence+                                  --  i.e. ic_need_inner after deleting+                                  --       (a) givens (b) binders of ic_binds++      ic_status   :: ImplicStatus+    }++implicationPrototype :: Implication+implicationPrototype+   = Implic { -- These fields must be initialised+              ic_tclvl      = panic "newImplic:tclvl"+            , ic_binds      = panic "newImplic:binds"+            , ic_info       = panic "newImplic:info"+            , ic_env        = panic "newImplic:env"+            , ic_warn_inaccessible = panic "newImplic:warn_inaccessible"++              -- The rest have sensible default values+            , ic_skols      = []+            , ic_telescope  = Nothing+            , ic_given      = []+            , ic_wanted     = emptyWC+            , ic_no_eqs     = False+            , ic_status     = IC_Unsolved+            , ic_need_inner = emptyVarSet+            , ic_need_outer = emptyVarSet }++data ImplicStatus+  = IC_Solved     -- All wanteds in the tree are solved, all the way down+       { ics_dead :: [EvVar] }  -- Subset of ic_given that are not needed+         -- See Note [Tracking redundant constraints] in GHC.Tc.Solver++  | IC_Insoluble  -- At least one insoluble constraint in the tree++  | IC_BadTelescope  -- solved, but the skolems in the telescope are out of+                     -- dependency order++  | IC_Unsolved   -- Neither of the above; might go either way++instance Outputable Implication where+  ppr (Implic { ic_tclvl = tclvl, ic_skols = skols+              , ic_given = given, ic_no_eqs = no_eqs+              , ic_wanted = wanted, ic_status = status+              , ic_binds = binds+              , ic_need_inner = need_in, ic_need_outer = need_out+              , ic_info = info })+   = hang (text "Implic" <+> lbrace)+        2 (sep [ text "TcLevel =" <+> ppr tclvl+               , text "Skolems =" <+> pprTyVars skols+               , text "No-eqs =" <+> ppr no_eqs+               , text "Status =" <+> ppr status+               , hang (text "Given =")  2 (pprEvVars given)+               , hang (text "Wanted =") 2 (ppr wanted)+               , text "Binds =" <+> ppr binds+               , whenPprDebug (text "Needed inner =" <+> ppr need_in)+               , whenPprDebug (text "Needed outer =" <+> ppr need_out)+               , pprSkolInfo info ] <+> rbrace)++instance Outputable ImplicStatus where+  ppr IC_Insoluble    = text "Insoluble"+  ppr IC_BadTelescope = text "Bad telescope"+  ppr IC_Unsolved     = text "Unsolved"+  ppr (IC_Solved { ics_dead = dead })+    = text "Solved" <+> (braces (text "Dead givens =" <+> ppr dead))++{- Note [Checking telescopes]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When kind-checking a /user-written/ type, we might have a "bad telescope"+like this one:+  data SameKind :: forall k. k -> k -> Type+  type Foo :: forall a k (b :: k). SameKind a b -> Type++The kind of 'a' mentions 'k' which is bound after 'a'.  Oops.++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 }++* Having solved {wanted}, before discarding the now-solved implication,+  the constraint solver checks the dependency order of the skolem+  variables (ic_skols).  This is done in setImplicationStatus.++* This check is only necessary if the implication was born from a+  user-written signature.  If, say, it comes from checking a pattern+  match that binds existentials, where the type of the data constructor+  is known to be valid (it in tcConPat), no need for the check.++  So the check is done if and only if ic_telescope is (Just blah).++* If ic_telesope is (Just d), the d::SDoc displays the original,+  user-written type variables.++* Be careful /NOT/ to discard an implication with non-Nothing+  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++Note [Needed evidence variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Th ic_need_evs field holds the free vars of ic_binds, and all the+ic_binds in nested implications.++  * Main purpose: if one of the ic_givens is not mentioned in here, it+    is redundant.++  * solveImplication may drop an implication altogether if it has no+    remaining 'wanteds'. But we still track the free vars of its+    evidence binds, even though it has now disappeared.++Note [Shadowing in a constraint]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We assume NO SHADOWING in a constraint.  Specifically+ * The unification variables are all implicitly quantified at top+   level, and are all unique+ * The skolem variables bound in ic_skols are all freah when the+   implication is created.+So we can safely substitute. For example, if we have+   forall a.  a~Int => ...(forall b. ...a...)...+we can push the (a~Int) constraint inwards in the "givens" without+worrying that 'b' might clash.++Note [Skolems in an implication]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The skolems in an implication are not there to perform a skolem escape+check.  That happens because all the environment variables are in the+untouchables, and therefore cannot be unified with anything at all,+let alone the skolems.++Instead, ic_skols is used only when considering floating a constraint+outside the implication in GHC.Tc.Solver.floatEqualities or+GHC.Tc.Solver.approximateImplications++Note [Insoluble constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Some of the errors that we get during canonicalization are best+reported when all constraints have been simplified as much as+possible. For instance, assume that during simplification the+following constraints arise:++ [Wanted]   F alpha ~  uf1+ [Wanted]   beta ~ uf1 beta++When canonicalizing the wanted (beta ~ uf1 beta), if we eagerly fail+we will simply see a message:+    'Can't construct the infinite type  beta ~ uf1 beta'+and the user has no idea what the uf1 variable is.++Instead our plan is that we will NOT fail immediately, but:+    (1) Record the "frozen" error in the ic_insols field+    (2) Isolate the offending constraint from the rest of the inerts+    (3) Keep on simplifying/canonicalizing++At the end, we will hopefully have substituted uf1 := F alpha, and we+will be able to report a more informative error:+    'Can't construct the infinite type beta ~ F alpha beta'++Insoluble constraints *do* include Derived constraints. For example,+a functional dependency might give rise to [D] Int ~ Bool, and we must+report that.  If insolubles did not contain Deriveds, reportErrors would+never see it.+++************************************************************************+*                                                                      *+            Pretty printing+*                                                                      *+************************************************************************+-}++pprEvVars :: [EvVar] -> SDoc    -- Print with their types+pprEvVars ev_vars = vcat (map pprEvVarWithType ev_vars)++pprEvVarTheta :: [EvVar] -> SDoc+pprEvVarTheta ev_vars = pprTheta (map evVarPred ev_vars)++pprEvVarWithType :: EvVar -> SDoc+pprEvVarWithType v = ppr v <+> dcolon <+> pprType (evVarPred v)++++wrapType :: Type -> [TyVar] -> [PredType] -> Type+wrapType ty skols givens = mkSpecForAllTys skols $ mkPhiTy givens ty+++{-+************************************************************************+*                                                                      *+            CtEvidence+*                                                                      *+************************************************************************++Note [Evidence field of CtEvidence]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+During constraint solving we never look at the type of ctev_evar/ctev_dest;+instead we look at the ctev_pred field.  The evtm/evar field+may be un-zonked.++Note [Bind new Givens immediately]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+For Givens we make new EvVars and bind them immediately. Two main reasons:+  * Gain sharing.  E.g. suppose we start with g :: C a b, where+       class D a => C a b+       class (E a, F a) => D a+    If we generate all g's superclasses as separate EvTerms we might+    get    selD1 (selC1 g) :: E a+           selD2 (selC1 g) :: F a+           selC1 g :: D a+    which we could do more economically as:+           g1 :: D a = selC1 g+           g2 :: E a = selD1 g1+           g3 :: F a = selD2 g1++  * For *coercion* evidence we *must* bind each given:+      class (a~b) => C a b where ....+      f :: C a b => ....+    Then in f's Givens we have g:(C a b) and the superclass sc(g,0):a~b.+    But that superclass selector can't (yet) appear in a coercion+    (see evTermCoercion), so the easy thing is to bind it to an Id.++So a Given has EvVar inside it rather than (as previously) an EvTerm.++-}++-- | A place for type-checking evidence to go after it is generated.+-- Wanted equalities are always HoleDest; other wanteds are always+-- EvVarDest.+data TcEvDest+  = EvVarDest EvVar         -- ^ bind this var to the evidence+              -- EvVarDest is always used for non-type-equalities+              -- e.g. class constraints++  | HoleDest  CoercionHole  -- ^ fill in this hole with the evidence+              -- HoleDest is always used for type-equalities+              -- See Note [Coercion holes] in GHC.Core.TyCo.Rep++data CtEvidence+  = CtGiven    -- Truly given, not depending on subgoals+      { ctev_pred :: TcPredType      -- See Note [Ct/evidence invariant]+      , ctev_evar :: EvVar           -- See Note [Evidence field of CtEvidence]+      , ctev_loc  :: CtLoc }+++  | CtWanted   -- Wanted goal+      { ctev_pred :: TcPredType     -- See Note [Ct/evidence invariant]+      , ctev_dest :: TcEvDest+      , ctev_nosh :: ShadowInfo     -- See Note [Constraint flavours]+      , ctev_loc  :: CtLoc }++  | CtDerived  -- A goal that we don't really have to solve and can't+               -- immediately rewrite anything other than a derived+               -- (there's no evidence!) but if we do manage to solve+               -- it may help in solving other goals.+      { ctev_pred :: TcPredType+      , ctev_loc  :: CtLoc }++ctEvPred :: CtEvidence -> TcPredType+-- The predicate of a flavor+ctEvPred = ctev_pred++ctEvLoc :: CtEvidence -> CtLoc+ctEvLoc = ctev_loc++ctEvOrigin :: CtEvidence -> CtOrigin+ctEvOrigin = ctLocOrigin . ctEvLoc++-- | Get the equality relation relevant for a 'CtEvidence'+ctEvEqRel :: CtEvidence -> EqRel+ctEvEqRel = predTypeEqRel . ctEvPred++-- | Get the role relevant for a 'CtEvidence'+ctEvRole :: CtEvidence -> Role+ctEvRole = eqRelRole . ctEvEqRel++ctEvTerm :: CtEvidence -> EvTerm+ctEvTerm ev = EvExpr (ctEvExpr ev)++ctEvExpr :: CtEvidence -> EvExpr+ctEvExpr ev@(CtWanted { ctev_dest = HoleDest _ })+            = Coercion $ ctEvCoercion ev+ctEvExpr ev = evId (ctEvEvId ev)++ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion+ctEvCoercion (CtGiven { ctev_evar = ev_id })+  = mkTcCoVarCo ev_id+ctEvCoercion (CtWanted { ctev_dest = dest })+  | HoleDest hole <- dest+  = -- ctEvCoercion is only called on type equalities+    -- and they always have HoleDests+    mkHoleCo hole+ctEvCoercion ev+  = pprPanic "ctEvCoercion" (ppr ev)++ctEvEvId :: CtEvidence -> EvVar+ctEvEvId (CtWanted { ctev_dest = EvVarDest ev }) = ev+ctEvEvId (CtWanted { ctev_dest = HoleDest h })   = coHoleCoVar h+ctEvEvId (CtGiven  { ctev_evar = ev })           = ev+ctEvEvId ctev@(CtDerived {}) = pprPanic "ctEvId:" (ppr ctev)++instance Outputable TcEvDest where+  ppr (HoleDest h)   = text "hole" <> ppr h+  ppr (EvVarDest ev) = ppr ev++instance Outputable CtEvidence where+  ppr ev = ppr (ctEvFlavour ev)+           <+> pp_ev+           <+> braces (ppr (ctl_depth (ctEvLoc ev))) <> dcolon+                  -- Show the sub-goal depth too+           <+> ppr (ctEvPred ev)+    where+      pp_ev = case ev of+             CtGiven { ctev_evar = v } -> ppr v+             CtWanted {ctev_dest = d } -> ppr d+             CtDerived {}              -> text "_"++isWanted :: CtEvidence -> Bool+isWanted (CtWanted {}) = True+isWanted _ = False++isGiven :: CtEvidence -> Bool+isGiven (CtGiven {})  = True+isGiven _ = False++isDerived :: CtEvidence -> Bool+isDerived (CtDerived {}) = True+isDerived _              = False++{-+%************************************************************************+%*                                                                      *+            CtFlavour+%*                                                                      *+%************************************************************************++Note [Constraint flavours]+~~~~~~~~~~~~~~~~~~~~~~~~~~+Constraints come in four flavours:++* [G] Given: we have evidence++* [W] Wanted WOnly: we want evidence++* [D] Derived: any solution must satisfy this constraint, but+      we don't need evidence for it.  Examples include:+        - superclasses of [W] class constraints+        - equalities arising from functional dependencies+          or injectivity++* [WD] Wanted WDeriv: a single constraint that represents+                      both [W] and [D]+  We keep them paired as one both for efficiency, and because+  when we have a finite map  F tys -> CFunEqCan, it's inconvenient+  to have two CFunEqCans in the range++The ctev_nosh field of a Wanted distinguishes between [W] and [WD]++Wanted constraints are born as [WD], but are split into [W] and its+"shadow" [D] in GHC.Tc.Solver.Monad.maybeEmitShadow.++See Note [The improvement story and derived shadows] in GHC.Tc.Solver.Monad+-}++data CtFlavour  -- See Note [Constraint flavours]+  = Given+  | Wanted ShadowInfo+  | Derived+  deriving Eq++data ShadowInfo+  = WDeriv   -- [WD] This Wanted constraint has no Derived shadow,+             -- so it behaves like a pair of a Wanted and a Derived+  | WOnly    -- [W] It has a separate derived shadow+             -- See Note [The improvement story and derived shadows] in GHC.Tc.Solver.Monad+  deriving( Eq )++isGivenOrWDeriv :: CtFlavour -> Bool+isGivenOrWDeriv Given           = True+isGivenOrWDeriv (Wanted WDeriv) = True+isGivenOrWDeriv _               = False++instance Outputable CtFlavour where+  ppr Given           = text "[G]"+  ppr (Wanted WDeriv) = text "[WD]"+  ppr (Wanted WOnly)  = text "[W]"+  ppr Derived         = text "[D]"++ctEvFlavour :: CtEvidence -> CtFlavour+ctEvFlavour (CtWanted { ctev_nosh = nosh }) = Wanted nosh+ctEvFlavour (CtGiven {})                    = Given+ctEvFlavour (CtDerived {})                  = Derived++-- | Whether or not one 'Ct' can rewrite another is determined by its+-- flavour and its equality relation. See also+-- Note [Flavours with roles] in GHC.Tc.Solver.Monad+type CtFlavourRole = (CtFlavour, EqRel)++-- | Extract the flavour, role, and boxity from a 'CtEvidence'+ctEvFlavourRole :: CtEvidence -> CtFlavourRole+ctEvFlavourRole ev = (ctEvFlavour ev, ctEvEqRel ev)++-- | Extract the flavour and role from a 'Ct'+ctFlavourRole :: Ct -> CtFlavourRole+-- Uses short-cuts to role for special cases+ctFlavourRole (CDictCan { cc_ev = ev })+  = (ctEvFlavour ev, NomEq)+ctFlavourRole (CTyEqCan { cc_ev = ev, cc_eq_rel = eq_rel })+  = (ctEvFlavour ev, eq_rel)+ctFlavourRole (CFunEqCan { cc_ev = ev })+  = (ctEvFlavour ev, NomEq)+ctFlavourRole (CHoleCan { cc_ev = ev })+  = (ctEvFlavour ev, NomEq)  -- NomEq: CHoleCans can be rewritten by+                             -- by nominal equalities but empahatically+                             -- not by representational equalities+ctFlavourRole ct+  = ctEvFlavourRole (ctEvidence ct)++{- Note [eqCanRewrite]+~~~~~~~~~~~~~~~~~~~~~~+(eqCanRewrite ct1 ct2) holds if the constraint ct1 (a CTyEqCan of form+tv ~ ty) can be used to rewrite ct2.  It must satisfy the properties of+a can-rewrite relation, see Definition [Can-rewrite relation] in+GHC.Tc.Solver.Monad.++With the solver handling Coercible constraints like equality constraints,+the rewrite conditions must take role into account, never allowing+a representational equality to rewrite a nominal one.++Note [Wanteds do not rewrite Wanteds]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We don't allow Wanteds to rewrite Wanteds, because that can give rise+to very confusing type error messages.  A good example is #8450.+Here's another+   f :: a -> Bool+   f x = ( [x,'c'], [x,True] ) `seq` True+Here we get+  [W] a ~ Char+  [W] a ~ Bool+but we do not want to complain about Bool ~ Char!++Note [Deriveds do rewrite Deriveds]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+However we DO allow Deriveds to rewrite Deriveds, because that's how+improvement works; see Note [The improvement story] in GHC.Tc.Solver.Interact.++However, for now at least I'm only letting (Derived,NomEq) rewrite+(Derived,NomEq) and not doing anything for ReprEq.  If we have+    eqCanRewriteFR (Derived, NomEq) (Derived, _)  = True+then we lose property R2 of Definition [Can-rewrite relation]+in GHC.Tc.Solver.Monad+  R2.  If f1 >= f, and f2 >= f,+       then either f1 >= f2 or f2 >= f1+Consider f1 = (Given, ReprEq)+         f2 = (Derived, NomEq)+          f = (Derived, ReprEq)++I thought maybe we could never get Derived ReprEq constraints, but+we can; straight from the Wanteds during improvement. And from a Derived+ReprEq we could conceivably get a Derived NomEq improvement (by decomposing+a type constructor with Nomninal role), and hence unify.+-}++eqCanRewrite :: EqRel -> EqRel -> Bool+eqCanRewrite NomEq  _      = True+eqCanRewrite ReprEq ReprEq = True+eqCanRewrite ReprEq NomEq  = False++eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool+-- Can fr1 actually rewrite fr2?+-- Very important function!+-- See Note [eqCanRewrite]+-- See Note [Wanteds do not rewrite Wanteds]+-- See Note [Deriveds do rewrite Deriveds]+eqCanRewriteFR (Given,         r1)    (_,       r2)    = eqCanRewrite r1 r2+eqCanRewriteFR (Wanted WDeriv, NomEq) (Derived, NomEq) = True+eqCanRewriteFR (Derived,       NomEq) (Derived, NomEq) = True+eqCanRewriteFR _                      _                = False++eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool+-- Is it /possible/ that fr1 can rewrite fr2?+-- This is used when deciding which inerts to kick out,+-- at which time a [WD] inert may be split into [W] and [D]+eqMayRewriteFR (Wanted WDeriv, NomEq) (Wanted WDeriv, NomEq) = True+eqMayRewriteFR (Derived,       NomEq) (Wanted WDeriv, NomEq) = True+eqMayRewriteFR fr1 fr2 = eqCanRewriteFR fr1 fr2++-----------------+{- Note [funEqCanDischarge]+~~~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have two CFunEqCans with the same LHS:+    (x1:F ts ~ f1) `funEqCanDischarge` (x2:F ts ~ f2)+Can we drop x2 in favour of x1, either unifying+f2 (if it's a flatten meta-var) or adding a new Given+(f1 ~ f2), if x2 is a Given?++Answer: yes if funEqCanDischarge is true.+-}++funEqCanDischarge+  :: CtEvidence -> CtEvidence+  -> ( SwapFlag   -- NotSwapped => lhs can discharge rhs+                  -- Swapped    => rhs can discharge lhs+     , Bool)      -- True <=> upgrade non-discharded one+                  --          from [W] to [WD]+-- See Note [funEqCanDischarge]+funEqCanDischarge ev1 ev2+  = ASSERT2( ctEvEqRel ev1 == NomEq, ppr ev1 )+    ASSERT2( ctEvEqRel ev2 == NomEq, ppr ev2 )+    -- CFunEqCans are all Nominal, hence asserts+    funEqCanDischargeF (ctEvFlavour ev1) (ctEvFlavour ev2)++funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool)+funEqCanDischargeF Given           _               = (NotSwapped, False)+funEqCanDischargeF _               Given           = (IsSwapped,  False)+funEqCanDischargeF (Wanted WDeriv) _               = (NotSwapped, False)+funEqCanDischargeF _               (Wanted WDeriv) = (IsSwapped,  True)+funEqCanDischargeF (Wanted WOnly)  (Wanted WOnly)  = (NotSwapped, False)+funEqCanDischargeF (Wanted WOnly)  Derived         = (NotSwapped, True)+funEqCanDischargeF Derived         (Wanted WOnly)  = (IsSwapped,  True)+funEqCanDischargeF Derived         Derived         = (NotSwapped, False)+++{- Note [eqCanDischarge]+~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we have two identical CTyEqCan equality constraints+(i.e. both LHS and RHS are the same)+      (x1:a~t) `eqCanDischarge` (xs:a~t)+Can we just drop x2 in favour of x1?++Answer: yes if eqCanDischarge is true.++Note that we do /not/ allow Wanted to discharge Derived.+We must keep both.  Why?  Because the Derived may rewrite+other Deriveds in the model whereas the Wanted cannot.++However a Wanted can certainly discharge an identical Wanted.  So+eqCanDischarge does /not/ define a can-rewrite relation in the+sense of Definition [Can-rewrite relation] in GHC.Tc.Solver.Monad.++We /do/ say that a [W] can discharge a [WD].  In evidence terms it+certainly can, and the /caller/ arranges that the otherwise-lost [D]+is spat out as a new Derived.  -}++eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool+-- See Note [eqCanDischarge]+eqCanDischargeFR (f1,r1) (f2, r2) =  eqCanRewrite r1 r2+                                  && eqCanDischargeF f1 f2++eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool+eqCanDischargeF Given   _                  = True+eqCanDischargeF (Wanted _)      (Wanted _) = True+eqCanDischargeF (Wanted WDeriv) Derived    = True+eqCanDischargeF Derived         Derived    = True+eqCanDischargeF _               _          = False+++{-+************************************************************************+*                                                                      *+            SubGoalDepth+*                                                                      *+************************************************************************++Note [SubGoalDepth]+~~~~~~~~~~~~~~~~~~~+The 'SubGoalDepth' takes care of stopping the constraint solver from looping.++The counter starts at zero and increases. It includes dictionary constraints,+equality simplification, and type family reduction. (Why combine these? Because+it's actually quite easy to mistake one for another, in sufficiently involved+scenarios, like ConstraintKinds.)++The flag -freduction-depth=n fixes the maximium level.++* The counter includes the depth of type class instance declarations.  Example:+     [W] d{7} : Eq [Int]+  That is d's dictionary-constraint depth is 7.  If we use the instance+     $dfEqList :: Eq a => Eq [a]+  to simplify it, we get+     d{7} = $dfEqList d'{8}+  where d'{8} : Eq Int, and d' has depth 8.++  For civilised (decidable) instance declarations, each increase of+  depth removes a type constructor from the type, so the depth never+  gets big; i.e. is bounded by the structural depth of the type.++* The counter also increments when resolving+equalities involving type functions. Example:+  Assume we have a wanted at depth 7:+    [W] d{7} : F () ~ a+  If there is a type function equation "F () = Int", this would be rewritten to+    [W] d{8} : Int ~ a+  and remembered as having depth 8.++  Again, without UndecidableInstances, this counter is bounded, but without it+  can resolve things ad infinitum. Hence there is a maximum level.++* Lastly, every time an equality is rewritten, the counter increases. Again,+  rewriting an equality constraint normally makes progress, but it's possible+  the "progress" is just the reduction of an infinitely-reducing type family.+  Hence we need to track the rewrites.++When compiling a program requires a greater depth, then GHC recommends turning+off this check entirely by setting -freduction-depth=0. This is because the+exact number that works is highly variable, and is likely to change even between+minor releases. Because this check is solely to prevent infinite compilation+times, it seems safe to disable it when a user has ascertained that their program+doesn't loop at the type level.++-}++-- | See Note [SubGoalDepth]+newtype SubGoalDepth = SubGoalDepth Int+  deriving (Eq, Ord, Outputable)++initialSubGoalDepth :: SubGoalDepth+initialSubGoalDepth = SubGoalDepth 0++bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth+bumpSubGoalDepth (SubGoalDepth n) = SubGoalDepth (n + 1)++maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth+maxSubGoalDepth (SubGoalDepth n) (SubGoalDepth m) = SubGoalDepth (n `max` m)++subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool+subGoalDepthExceeded dflags (SubGoalDepth d)+  = mkIntWithInf d > reductionDepth dflags++{-+************************************************************************+*                                                                      *+            CtLoc+*                                                                      *+************************************************************************++The 'CtLoc' gives information about where a constraint came from.+This is important for decent error message reporting because+dictionaries don't appear in the original source code.+type will evolve...++-}++data CtLoc = CtLoc { ctl_origin :: CtOrigin+                   , ctl_env    :: TcLclEnv+                   , ctl_t_or_k :: Maybe TypeOrKind  -- OK if we're not sure+                   , ctl_depth  :: !SubGoalDepth }++  -- The TcLclEnv includes particularly+  --    source location:  tcl_loc   :: RealSrcSpan+  --    context:          tcl_ctxt  :: [ErrCtxt]+  --    binder stack:     tcl_bndrs :: TcBinderStack+  --    level:            tcl_tclvl :: TcLevel++mkKindLoc :: TcType -> TcType   -- original *types* being compared+          -> CtLoc -> CtLoc+mkKindLoc s1 s2 loc = setCtLocOrigin (toKindLoc loc)+                        (KindEqOrigin s1 (Just s2) (ctLocOrigin loc)+                                      (ctLocTypeOrKind_maybe loc))++-- | Take a CtLoc and moves it to the kind level+toKindLoc :: CtLoc -> CtLoc+toKindLoc loc = loc { ctl_t_or_k = Just KindLevel }++mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc+mkGivenLoc tclvl skol_info env+  = CtLoc { ctl_origin = GivenOrigin skol_info+          , ctl_env    = setLclEnvTcLevel env tclvl+          , ctl_t_or_k = Nothing    -- this only matters for error msgs+          , ctl_depth  = initialSubGoalDepth }++ctLocEnv :: CtLoc -> TcLclEnv+ctLocEnv = ctl_env++ctLocLevel :: CtLoc -> TcLevel+ctLocLevel loc = getLclEnvTcLevel (ctLocEnv loc)++ctLocDepth :: CtLoc -> SubGoalDepth+ctLocDepth = ctl_depth++ctLocOrigin :: CtLoc -> CtOrigin+ctLocOrigin = ctl_origin++ctLocSpan :: CtLoc -> RealSrcSpan+ctLocSpan (CtLoc { ctl_env = lcl}) = getLclEnvLoc lcl++ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind+ctLocTypeOrKind_maybe = ctl_t_or_k++setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc+setCtLocSpan ctl@(CtLoc { ctl_env = lcl }) loc = setCtLocEnv ctl (setLclEnvLoc lcl loc)++bumpCtLocDepth :: CtLoc -> CtLoc+bumpCtLocDepth loc@(CtLoc { ctl_depth = d }) = loc { ctl_depth = bumpSubGoalDepth d }++setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc+setCtLocOrigin ctl orig = ctl { ctl_origin = orig }++updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc+updateCtLocOrigin ctl@(CtLoc { ctl_origin = orig }) upd+  = ctl { ctl_origin = upd orig }++setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc+setCtLocEnv ctl env = ctl { ctl_env = env }++pprCtLoc :: CtLoc -> SDoc+-- "arising from ... at ..."+-- Not an instance of Outputable because of the "arising from" prefix+pprCtLoc (CtLoc { ctl_origin = o, ctl_env = lcl})+  = sep [ pprCtOrigin o+        , text "at" <+> ppr (getLclEnvLoc lcl)]
+ compiler/GHC/Tc/Types/Evidence.hs view
@@ -0,0 +1,1026 @@+-- (c) The University of Glasgow 2006++{-# LANGUAGE CPP, DeriveDataTypeable #-}+{-# LANGUAGE LambdaCase #-}++module GHC.Tc.Types.Evidence (++  -- * HsWrapper+  HsWrapper(..),+  (<.>), mkWpTyApps, mkWpEvApps, mkWpEvVarApps, mkWpTyLams,+  mkWpLams, mkWpLet, mkWpCastN, mkWpCastR, collectHsWrapBinders,+  mkWpFun, idHsWrapper, isIdHsWrapper, isErasableHsWrapper,+  pprHsWrapper,++  -- * Evidence bindings+  TcEvBinds(..), EvBindsVar(..),+  EvBindMap(..), emptyEvBindMap, extendEvBinds,+  lookupEvBind, evBindMapBinds, foldEvBindMap, filterEvBindMap,+  isEmptyEvBindMap,+  EvBind(..), emptyTcEvBinds, isEmptyTcEvBinds, mkGivenEvBind, mkWantedEvBind,+  evBindVar, isCoEvBindsVar,++  -- * EvTerm (already a CoreExpr)+  EvTerm(..), EvExpr,+  evId, evCoercion, evCast, evDFunApp,  evDataConApp, evSelector,+  mkEvCast, evVarsOfTerm, mkEvScSelectors, evTypeable, findNeededEvVars,++  evTermCoercion, evTermCoercion_maybe,+  EvCallStack(..),+  EvTypeable(..),++  -- * TcCoercion+  TcCoercion, TcCoercionR, TcCoercionN, TcCoercionP, CoercionHole,+  TcMCoercion,+  Role(..), LeftOrRight(..), pickLR,+  mkTcReflCo, mkTcNomReflCo, mkTcRepReflCo,+  mkTcTyConAppCo, mkTcAppCo, mkTcFunCo,+  mkTcAxInstCo, mkTcUnbranchedAxInstCo, mkTcForAllCo, mkTcForAllCos,+  mkTcSymCo, mkTcTransCo, mkTcNthCo, mkTcLRCo, mkTcSubCo, maybeTcSubCo,+  tcDowngradeRole,+  mkTcAxiomRuleCo, mkTcGReflRightCo, mkTcGReflLeftCo, mkTcPhantomCo,+  mkTcCoherenceLeftCo,+  mkTcCoherenceRightCo,+  mkTcKindCo,+  tcCoercionKind, coVarsOfTcCo,+  mkTcCoVarCo,+  isTcReflCo, isTcReflexiveCo, isTcGReflMCo, tcCoToMCo,+  tcCoercionRole,+  unwrapIP, wrapIP,++  -- * QuoteWrapper+  QuoteWrapper(..), applyQuoteWrapper, quoteWrapperTyVarTy+  ) where+#include "HsVersions.h"++import GHC.Prelude++import GHC.Types.Var+import GHC.Core.Coercion.Axiom+import GHC.Core.Coercion+import GHC.Core.Ppr ()   -- Instance OutputableBndr TyVar+import GHC.Tc.Utils.TcType+import GHC.Core.Type+import GHC.Core.TyCon+import GHC.Core.DataCon( DataCon, dataConWrapId )+import GHC.Core.Class( Class )+import GHC.Builtin.Names+import GHC.Types.Var.Env+import GHC.Types.Var.Set+import GHC.Core.Predicate+import GHC.Types.Name+import GHC.Data.Pair++import GHC.Core+import GHC.Core.Class ( classSCSelId )+import GHC.Core.FVs   ( exprSomeFreeVars )++import GHC.Utils.Misc+import GHC.Data.Bag+import qualified Data.Data as Data+import GHC.Utils.Outputable+import GHC.Types.SrcLoc+import Data.IORef( IORef )+import GHC.Types.Unique.Set++{-+Note [TcCoercions]+~~~~~~~~~~~~~~~~~~+| TcCoercions are a hack used by the typechecker. Normally,+Coercions have free variables of type (a ~# b): we call these+CoVars. However, the type checker passes around equality evidence+(boxed up) at type (a ~ b).++An TcCoercion is simply a Coercion whose free variables have may be either+boxed or unboxed. After we are done with typechecking the desugarer finds the+boxed free variables, unboxes them, and creates a resulting real Coercion with+kosher free variables.++-}++type TcCoercion  = Coercion+type TcCoercionN = CoercionN    -- A Nominal          coercion ~N+type TcCoercionR = CoercionR    -- A Representational coercion ~R+type TcCoercionP = CoercionP    -- a phantom coercion+type TcMCoercion = MCoercion++mkTcReflCo             :: Role -> TcType -> TcCoercion+mkTcSymCo              :: TcCoercion -> TcCoercion+mkTcTransCo            :: TcCoercion -> TcCoercion -> TcCoercion+mkTcNomReflCo          :: TcType -> TcCoercionN+mkTcRepReflCo          :: TcType -> TcCoercionR+mkTcTyConAppCo         :: Role -> TyCon -> [TcCoercion] -> TcCoercion+mkTcAppCo              :: TcCoercion -> TcCoercionN -> TcCoercion+mkTcFunCo              :: Role -> TcCoercion -> TcCoercion -> TcCoercion+mkTcAxInstCo           :: Role -> CoAxiom br -> BranchIndex+                       -> [TcType] -> [TcCoercion] -> TcCoercion+mkTcUnbranchedAxInstCo :: CoAxiom Unbranched -> [TcType]+                       -> [TcCoercion] -> TcCoercionR+mkTcForAllCo           :: TyVar -> TcCoercionN -> TcCoercion -> TcCoercion+mkTcForAllCos          :: [(TyVar, TcCoercionN)] -> TcCoercion -> TcCoercion+mkTcNthCo              :: Role -> Int -> TcCoercion -> TcCoercion+mkTcLRCo               :: LeftOrRight -> TcCoercion -> TcCoercion+mkTcSubCo              :: TcCoercionN -> TcCoercionR+tcDowngradeRole        :: Role -> Role -> TcCoercion -> TcCoercion+mkTcAxiomRuleCo        :: CoAxiomRule -> [TcCoercion] -> TcCoercionR+mkTcGReflRightCo       :: Role -> TcType -> TcCoercionN -> TcCoercion+mkTcGReflLeftCo        :: Role -> TcType -> TcCoercionN -> TcCoercion+mkTcCoherenceLeftCo    :: Role -> TcType -> TcCoercionN+                       -> TcCoercion -> TcCoercion+mkTcCoherenceRightCo   :: Role -> TcType -> TcCoercionN+                       -> TcCoercion -> TcCoercion+mkTcPhantomCo          :: TcCoercionN -> TcType -> TcType -> TcCoercionP+mkTcKindCo             :: TcCoercion -> TcCoercionN+mkTcCoVarCo            :: CoVar -> TcCoercion++tcCoercionKind         :: TcCoercion -> Pair TcType+tcCoercionRole         :: TcCoercion -> Role+coVarsOfTcCo           :: TcCoercion -> TcTyCoVarSet+isTcReflCo             :: TcCoercion -> Bool+isTcGReflMCo           :: TcMCoercion -> Bool++-- | This version does a slow check, calculating the related types and seeing+-- if they are equal.+isTcReflexiveCo        :: TcCoercion -> Bool++mkTcReflCo             = mkReflCo+mkTcSymCo              = mkSymCo+mkTcTransCo            = mkTransCo+mkTcNomReflCo          = mkNomReflCo+mkTcRepReflCo          = mkRepReflCo+mkTcTyConAppCo         = mkTyConAppCo+mkTcAppCo              = mkAppCo+mkTcFunCo              = mkFunCo+mkTcAxInstCo           = mkAxInstCo+mkTcUnbranchedAxInstCo = mkUnbranchedAxInstCo Representational+mkTcForAllCo           = mkForAllCo+mkTcForAllCos          = mkForAllCos+mkTcNthCo              = mkNthCo+mkTcLRCo               = mkLRCo+mkTcSubCo              = mkSubCo+tcDowngradeRole        = downgradeRole+mkTcAxiomRuleCo        = mkAxiomRuleCo+mkTcGReflRightCo       = mkGReflRightCo+mkTcGReflLeftCo        = mkGReflLeftCo+mkTcCoherenceLeftCo    = mkCoherenceLeftCo+mkTcCoherenceRightCo   = mkCoherenceRightCo+mkTcPhantomCo          = mkPhantomCo+mkTcKindCo             = mkKindCo+mkTcCoVarCo            = mkCoVarCo++tcCoercionKind         = coercionKind+tcCoercionRole         = coercionRole+coVarsOfTcCo           = coVarsOfCo+isTcReflCo             = isReflCo+isTcGReflMCo           = isGReflMCo+isTcReflexiveCo        = isReflexiveCo++tcCoToMCo :: TcCoercion -> TcMCoercion+tcCoToMCo = coToMCo++-- | If the EqRel is ReprEq, makes a SubCo; otherwise, does nothing.+-- Note that the input coercion should always be nominal.+maybeTcSubCo :: EqRel -> TcCoercion -> TcCoercion+maybeTcSubCo NomEq  = id+maybeTcSubCo ReprEq = mkTcSubCo+++{-+%************************************************************************+%*                                                                      *+                  HsWrapper+*                                                                      *+************************************************************************+-}++data HsWrapper+  = WpHole                      -- The identity coercion++  | WpCompose HsWrapper HsWrapper+       -- (wrap1 `WpCompose` wrap2)[e] = wrap1[ wrap2[ e ]]+       --+       -- Hence  (\a. []) `WpCompose` (\b. []) = (\a b. [])+       -- But    ([] a)   `WpCompose` ([] b)   = ([] b a)++  | WpFun HsWrapper HsWrapper TcType SDoc+       -- (WpFun wrap1 wrap2 t1)[e] = \(x:t1). wrap2[ e wrap1[x] ]+       -- So note that if  wrap1 :: exp_arg <= act_arg+       --                  wrap2 :: act_res <= exp_res+       --           then   WpFun wrap1 wrap2 : (act_arg -> arg_res) <= (exp_arg -> exp_res)+       -- This isn't the same as for mkFunCo, but it has to be this way+       -- because we can't use 'sym' to flip around these HsWrappers+       -- 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 GHC.HsToCore.Monad++  | WpCast TcCoercionR        -- A cast:  [] `cast` co+                              -- Guaranteed not the identity coercion+                              -- At role Representational++        -- Evidence abstraction and application+        -- (both dictionaries and coercions)+  | WpEvLam EvVar               -- \d. []       the 'd' is an evidence variable+  | WpEvApp EvTerm              -- [] d         the 'd' is evidence for a constraint+        -- Kind and Type abstraction and application+  | WpTyLam TyVar       -- \a. []  the 'a' is a type/kind variable (not coercion var)+  | WpTyApp KindOrType  -- [] t    the 't' is a type (not coercion)+++  | WpLet TcEvBinds             -- Non-empty (or possibly non-empty) evidence bindings,+                                -- so that the identity coercion is always exactly WpHole++-- Cannot derive Data instance because SDoc is not Data (it stores a function).+-- So we do it manually:+instance Data.Data HsWrapper where+  gfoldl _ z WpHole             = z WpHole+  gfoldl k z (WpCompose a1 a2)  = z WpCompose `k` a1 `k` a2+  gfoldl k z (WpFun a1 a2 a3 _) = z wpFunEmpty `k` a1 `k` a2 `k` a3+  gfoldl k z (WpCast a1)        = z WpCast `k` a1+  gfoldl k z (WpEvLam a1)       = z WpEvLam `k` a1+  gfoldl k z (WpEvApp a1)       = z WpEvApp `k` a1+  gfoldl k z (WpTyLam a1)       = z WpTyLam `k` a1+  gfoldl k z (WpTyApp a1)       = z WpTyApp `k` a1+  gfoldl k z (WpLet a1)         = z WpLet `k` a1++  gunfold k z c = case Data.constrIndex c of+                    1 -> z WpHole+                    2 -> k (k (z WpCompose))+                    3 -> k (k (k (z wpFunEmpty)))+                    4 -> k (z WpCast)+                    5 -> k (z WpEvLam)+                    6 -> k (z WpEvApp)+                    7 -> k (z WpTyLam)+                    8 -> k (z WpTyApp)+                    _ -> k (z WpLet)++  toConstr WpHole          = wpHole_constr+  toConstr (WpCompose _ _) = wpCompose_constr+  toConstr (WpFun _ _ _ _) = wpFun_constr+  toConstr (WpCast _)      = wpCast_constr+  toConstr (WpEvLam _)     = wpEvLam_constr+  toConstr (WpEvApp _)     = wpEvApp_constr+  toConstr (WpTyLam _)     = wpTyLam_constr+  toConstr (WpTyApp _)     = wpTyApp_constr+  toConstr (WpLet _)       = wpLet_constr++  dataTypeOf _ = hsWrapper_dataType++hsWrapper_dataType :: Data.DataType+hsWrapper_dataType+  = Data.mkDataType "HsWrapper"+      [ wpHole_constr, wpCompose_constr, wpFun_constr, wpCast_constr+      , wpEvLam_constr, wpEvApp_constr, wpTyLam_constr, wpTyApp_constr+      , wpLet_constr]++wpHole_constr, wpCompose_constr, wpFun_constr, wpCast_constr, wpEvLam_constr,+  wpEvApp_constr, wpTyLam_constr, wpTyApp_constr, wpLet_constr :: Data.Constr+wpHole_constr    = mkHsWrapperConstr "WpHole"+wpCompose_constr = mkHsWrapperConstr "WpCompose"+wpFun_constr     = mkHsWrapperConstr "WpFun"+wpCast_constr    = mkHsWrapperConstr "WpCast"+wpEvLam_constr   = mkHsWrapperConstr "WpEvLam"+wpEvApp_constr   = mkHsWrapperConstr "WpEvApp"+wpTyLam_constr   = mkHsWrapperConstr "WpTyLam"+wpTyApp_constr   = mkHsWrapperConstr "WpTyApp"+wpLet_constr     = mkHsWrapperConstr "WpLet"++mkHsWrapperConstr :: String -> Data.Constr+mkHsWrapperConstr name = Data.mkConstr hsWrapper_dataType name [] Data.Prefix++wpFunEmpty :: HsWrapper -> HsWrapper -> TcType -> HsWrapper+wpFunEmpty c1 c2 t1 = WpFun c1 c2 t1 empty++(<.>) :: HsWrapper -> HsWrapper -> HsWrapper+WpHole <.> c = c+c <.> WpHole = c+c1 <.> c2    = c1 `WpCompose` c2++mkWpFun :: HsWrapper -> HsWrapper+        -> TcType    -- the "from" type of the first wrapper+        -> TcType    -- either type of the second wrapper (used only when the+                     -- second wrapper is the identity)+        -> SDoc      -- what caused you to want a WpFun? Something like "When converting ..."+        -> HsWrapper+mkWpFun WpHole       WpHole       _  _  _ = WpHole+mkWpFun WpHole       (WpCast co2) t1 _  _ = WpCast (mkTcFunCo Representational (mkTcRepReflCo t1) co2)+mkWpFun (WpCast co1) WpHole       _  t2 _ = WpCast (mkTcFunCo Representational (mkTcSymCo co1) (mkTcRepReflCo t2))+mkWpFun (WpCast co1) (WpCast co2) _  _  _ = WpCast (mkTcFunCo Representational (mkTcSymCo co1) co2)+mkWpFun co1          co2          t1 _  d = WpFun co1 co2 t1 d++mkWpCastR :: TcCoercionR -> HsWrapper+mkWpCastR co+  | isTcReflCo co = WpHole+  | otherwise     = ASSERT2(tcCoercionRole co == Representational, ppr co)+                    WpCast co++mkWpCastN :: TcCoercionN -> HsWrapper+mkWpCastN co+  | isTcReflCo co = WpHole+  | otherwise     = ASSERT2(tcCoercionRole co == Nominal, ppr co)+                    WpCast (mkTcSubCo co)+    -- The mkTcSubCo converts Nominal to Representational++mkWpTyApps :: [Type] -> HsWrapper+mkWpTyApps tys = mk_co_app_fn WpTyApp tys++mkWpEvApps :: [EvTerm] -> HsWrapper+mkWpEvApps args = mk_co_app_fn WpEvApp args++mkWpEvVarApps :: [EvVar] -> HsWrapper+mkWpEvVarApps vs = mk_co_app_fn WpEvApp (map (EvExpr . evId) vs)++mkWpTyLams :: [TyVar] -> HsWrapper+mkWpTyLams ids = mk_co_lam_fn WpTyLam ids++mkWpLams :: [Var] -> HsWrapper+mkWpLams ids = mk_co_lam_fn WpEvLam ids++mkWpLet :: TcEvBinds -> HsWrapper+-- This no-op is a quite a common case+mkWpLet (EvBinds b) | isEmptyBag b = WpHole+mkWpLet ev_binds                   = WpLet ev_binds++mk_co_lam_fn :: (a -> HsWrapper) -> [a] -> HsWrapper+mk_co_lam_fn f as = foldr (\x wrap -> f x <.> wrap) WpHole as++mk_co_app_fn :: (a -> HsWrapper) -> [a] -> HsWrapper+-- For applications, the *first* argument must+-- come *last* in the composition sequence+mk_co_app_fn f as = foldr (\x wrap -> wrap <.> f x) WpHole as++idHsWrapper :: HsWrapper+idHsWrapper = WpHole++isIdHsWrapper :: HsWrapper -> Bool+isIdHsWrapper WpHole = True+isIdHsWrapper _      = False++-- | Is the wrapper erasable, i.e., will not affect runtime semantics?+isErasableHsWrapper :: HsWrapper -> Bool+isErasableHsWrapper = go+  where+    go WpHole                  = True+    go (WpCompose wrap1 wrap2) = go wrap1 && go wrap2+    go WpFun{}                 = False+    go WpCast{}                = True+    go WpEvLam{}               = False -- case in point+    go WpEvApp{}               = False+    go WpTyLam{}               = True+    go WpTyApp{}               = True+    go WpLet{}                 = False++collectHsWrapBinders :: HsWrapper -> ([Var], HsWrapper)+-- Collect the outer lambda binders of a HsWrapper,+-- stopping as soon as you get to a non-lambda binder+collectHsWrapBinders wrap = go wrap []+  where+    -- go w ws = collectHsWrapBinders (w <.> w1 <.> ... <.> wn)+    go :: HsWrapper -> [HsWrapper] -> ([Var], HsWrapper)+    go (WpEvLam v)       wraps = add_lam v (gos wraps)+    go (WpTyLam v)       wraps = add_lam v (gos wraps)+    go (WpCompose w1 w2) wraps = go w1 (w2:wraps)+    go wrap              wraps = ([], foldl' (<.>) wrap wraps)++    gos []     = ([], WpHole)+    gos (w:ws) = go w ws++    add_lam v (vs,w) = (v:vs, w)++{-+************************************************************************+*                                                                      *+                  Evidence bindings+*                                                                      *+************************************************************************+-}++data TcEvBinds+  = TcEvBinds           -- Mutable evidence bindings+       EvBindsVar       -- Mutable because they are updated "later"+                        --    when an implication constraint is solved++  | EvBinds             -- Immutable after zonking+       (Bag EvBind)++data EvBindsVar+  = EvBindsVar {+      ebv_uniq :: Unique,+         -- The Unique is for debug printing only++      ebv_binds :: IORef EvBindMap,+      -- The main payload: the value-level evidence bindings+      --     (dictionaries etc)+      -- Some Given, some Wanted++      ebv_tcvs :: IORef CoVarSet+      -- The free Given coercion vars needed by Wanted coercions that+      -- are solved by filling in their HoleDest in-place. Since they+      -- don't appear in ebv_binds, we keep track of their free+      -- variables so that we can report unused given constraints+      -- See Note [Tracking redundant constraints] in GHC.Tc.Solver+    }++  | CoEvBindsVar {  -- See Note [Coercion evidence only]++      -- See above for comments on ebv_uniq, ebv_tcvs+      ebv_uniq :: Unique,+      ebv_tcvs :: IORef CoVarSet+    }++instance Data.Data TcEvBinds where+  -- Placeholder; we can't travers into TcEvBinds+  toConstr _   = abstractConstr "TcEvBinds"+  gunfold _ _  = error "gunfold"+  dataTypeOf _ = Data.mkNoRepType "TcEvBinds"++{- Note [Coercion evidence only]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Class constraints etc give rise to /term/ bindings for evidence, and+we have nowhere to put term bindings in /types/.  So in some places we+use CoEvBindsVar (see newCoTcEvBinds) to signal that no term-level+evidence bindings are allowed.  Notebly ():++  - Places in types where we are solving kind constraints (all of which+    are equalities); see solveEqualities, solveLocalEqualities++  - When unifying forall-types+-}++isCoEvBindsVar :: EvBindsVar -> Bool+isCoEvBindsVar (CoEvBindsVar {}) = True+isCoEvBindsVar (EvBindsVar {})   = False++-----------------+newtype EvBindMap+  = EvBindMap {+       ev_bind_varenv :: DVarEnv EvBind+    }       -- Map from evidence variables to evidence terms+            -- We use @DVarEnv@ here to get deterministic ordering when we+            -- turn it into a Bag.+            -- If we don't do that, when we generate let bindings for+            -- dictionaries in dsTcEvBinds they will be generated in random+            -- order.+            --+            -- For example:+            --+            -- let $dEq = GHC.Classes.$fEqInt in+            -- let $$dNum = GHC.Num.$fNumInt in ...+            --+            -- vs+            --+            -- let $dNum = GHC.Num.$fNumInt in+            -- let $dEq = GHC.Classes.$fEqInt in ...+            --+            -- See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why+            -- @UniqFM@ can lead to nondeterministic order.++emptyEvBindMap :: EvBindMap+emptyEvBindMap = EvBindMap { ev_bind_varenv = emptyDVarEnv }++extendEvBinds :: EvBindMap -> EvBind -> EvBindMap+extendEvBinds bs ev_bind+  = EvBindMap { ev_bind_varenv = extendDVarEnv (ev_bind_varenv bs)+                                               (eb_lhs ev_bind)+                                               ev_bind }++isEmptyEvBindMap :: EvBindMap -> Bool+isEmptyEvBindMap (EvBindMap m) = isEmptyDVarEnv m++lookupEvBind :: EvBindMap -> EvVar -> Maybe EvBind+lookupEvBind bs = lookupDVarEnv (ev_bind_varenv bs)++evBindMapBinds :: EvBindMap -> Bag EvBind+evBindMapBinds = foldEvBindMap consBag emptyBag++foldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a+foldEvBindMap k z bs = foldDVarEnv k z (ev_bind_varenv bs)++filterEvBindMap :: (EvBind -> Bool) -> EvBindMap -> EvBindMap+filterEvBindMap k (EvBindMap { ev_bind_varenv = env })+  = EvBindMap { ev_bind_varenv = filterDVarEnv k env }++instance Outputable EvBindMap where+  ppr (EvBindMap m) = ppr m++-----------------+-- All evidence is bound by EvBinds; no side effects+data EvBind+  = EvBind { eb_lhs      :: EvVar+           , eb_rhs      :: EvTerm+           , eb_is_given :: Bool  -- True <=> given+                 -- See Note [Tracking redundant constraints] in GHC.Tc.Solver+    }++evBindVar :: EvBind -> EvVar+evBindVar = eb_lhs++mkWantedEvBind :: EvVar -> EvTerm -> EvBind+mkWantedEvBind ev tm = EvBind { eb_is_given = False, eb_lhs = ev, eb_rhs = tm }++-- EvTypeable are never given, so we can work with EvExpr here instead of EvTerm+mkGivenEvBind :: EvVar -> EvTerm -> EvBind+mkGivenEvBind ev tm = EvBind { eb_is_given = True, eb_lhs = ev, eb_rhs = tm }+++-- An EvTerm is, conceptually, a CoreExpr that implements the constraint.+-- Unfortunately, we cannot just do+--   type EvTerm  = CoreExpr+-- Because of staging problems issues around EvTypeable+data EvTerm+  = EvExpr EvExpr++  | EvTypeable Type EvTypeable   -- Dictionary for (Typeable ty)++  | EvFun     -- /\as \ds. let binds in v+      { et_tvs   :: [TyVar]+      , et_given :: [EvVar]+      , et_binds :: TcEvBinds -- This field is why we need an EvFun+                              -- constructor, and can't just use EvExpr+      , et_body  :: EvVar }++  deriving Data.Data++type EvExpr = CoreExpr++-- An EvTerm is (usually) constructed by any of the constructors here+-- and those more complicates ones who were moved to module GHC.Tc.Types.EvTerm++-- | Any sort of evidence Id, including coercions+evId ::  EvId -> EvExpr+evId = Var++-- coercion bindings+-- See Note [Coercion evidence terms]+evCoercion :: TcCoercion -> EvTerm+evCoercion co = EvExpr (Coercion co)++-- | d |> co+evCast :: EvExpr -> TcCoercion -> EvTerm+evCast et tc | isReflCo tc = EvExpr et+             | otherwise   = EvExpr (Cast et tc)++-- Dictionary instance application+evDFunApp :: DFunId -> [Type] -> [EvExpr] -> EvTerm+evDFunApp df tys ets = EvExpr $ Var df `mkTyApps` tys `mkApps` ets++evDataConApp :: DataCon -> [Type] -> [EvExpr] -> EvTerm+evDataConApp dc tys ets = evDFunApp (dataConWrapId dc) tys ets++-- Selector id plus the types at which it+-- should be instantiated, used for HasField+-- dictionaries; see Note [HasField instances]+-- in TcInterface+evSelector :: Id -> [Type] -> [EvExpr] -> EvExpr+evSelector sel_id tys tms = Var sel_id `mkTyApps` tys `mkApps` tms++-- Dictionary for (Typeable ty)+evTypeable :: Type -> EvTypeable -> EvTerm+evTypeable = EvTypeable++-- | Instructions on how to make a 'Typeable' dictionary.+-- See Note [Typeable evidence terms]+data EvTypeable+  = EvTypeableTyCon TyCon [EvTerm]+    -- ^ Dictionary for @Typeable T@ where @T@ is a type constructor with all of+    -- its kind variables saturated. The @[EvTerm]@ is @Typeable@ evidence for+    -- the applied kinds..++  | EvTypeableTyApp EvTerm EvTerm+    -- ^ Dictionary for @Typeable (s t)@,+    -- given a dictionaries for @s@ and @t@.++  | EvTypeableTrFun EvTerm EvTerm+    -- ^ Dictionary for @Typeable (s -> t)@,+    -- given a dictionaries for @s@ and @t@.++  | EvTypeableTyLit EvTerm+    -- ^ Dictionary for a type literal,+    -- e.g. @Typeable "foo"@ or @Typeable 3@+    -- The 'EvTerm' is evidence of, e.g., @KnownNat 3@+    -- (see #10348)+  deriving Data.Data++-- | Evidence for @CallStack@ implicit parameters.+data EvCallStack+  -- See Note [Overview of implicit CallStacks]+  = EvCsEmpty+  | EvCsPushCall Name RealSrcSpan EvExpr+    -- ^ @EvCsPushCall name loc stk@ represents a call to @name@, occurring at+    -- @loc@, in a calling context @stk@.+  deriving Data.Data++{-+Note [Typeable evidence terms]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The EvTypeable data type looks isomorphic to Type, but the EvTerms+inside can be EvIds.  Eg+    f :: forall a. Typeable a => a -> TypeRep+    f x = typeRep (undefined :: Proxy [a])+Here for the (Typeable [a]) dictionary passed to typeRep we make+evidence+    dl :: Typeable [a] = EvTypeable [a]+                            (EvTypeableTyApp (EvTypeableTyCon []) (EvId d))+where+    d :: Typable a+is the lambda-bound dictionary passed into f.++Note [Coercion evidence terms]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A "coercion evidence term" takes one of these forms+   co_tm ::= EvId v           where v :: t1 ~# t2+           | EvCoercion co+           | EvCast co_tm co++We do quite often need to get a TcCoercion from an EvTerm; see+'evTermCoercion'.++INVARIANT: The evidence for any constraint with type (t1 ~# t2) is+a coercion evidence term.  Consider for example+    [G] d :: F Int a+If we have+    ax7 a :: F Int a ~ (a ~ Bool)+then we do NOT generate the constraint+    [G] (d |> ax7 a) :: a ~ Bool+because that does not satisfy the invariant (d is not a coercion variable).+Instead we make a binding+    g1 :: a~Bool = g |> ax7 a+and the constraint+    [G] g1 :: a~Bool+See #7238 and Note [Bind new Givens immediately] in GHC.Tc.Types.Constraint++Note [EvBinds/EvTerm]+~~~~~~~~~~~~~~~~~~~~~+How evidence is created and updated. Bindings for dictionaries,+and coercions and implicit parameters are carried around in TcEvBinds+which during constraint generation and simplification is always of the+form (TcEvBinds ref). After constraint simplification is finished it+will be transformed to t an (EvBinds ev_bag).++Evidence for coercions *SHOULD* be filled in using the TcEvBinds+However, all EvVars that correspond to *wanted* coercion terms in+an EvBind must be mutable variables so that they can be readily+inlined (by zonking) after constraint simplification is finished.++Conclusion: a new wanted coercion variable should be made mutable.+[Notice though that evidence variables that bind coercion terms+ from super classes will be "given" and hence rigid]+++Note [Overview of implicit CallStacks]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+(See https://gitlab.haskell.org/ghc/ghc/wikis/explicit-call-stack/implicit-locations)++The goal of CallStack evidence terms is to reify locations+in the program source as runtime values, without any support+from the RTS. We accomplish this by assigning a special meaning+to constraints of type GHC.Stack.Types.HasCallStack, an alias++  type HasCallStack = (?callStack :: CallStack)++Implicit parameters of type GHC.Stack.Types.CallStack (the name is not+important) are solved in three steps:++1. Occurrences of CallStack IPs are solved directly from the given IP,+   just like a regular IP. For example, the occurrence of `?stk` in++     error :: (?stk :: CallStack) => String -> a+     error s = raise (ErrorCall (s ++ prettyCallStack ?stk))++   will be solved for the `?stk` in `error`s context as before.++2. In a function call, instead of simply passing the given IP, we first+   append the current call-site to it. For example, consider a+   call to the callstack-aware `error` above.++     undefined :: (?stk :: CallStack) => a+     undefined = error "undefined!"++   Here we want to take the given `?stk` and append the current+   call-site, before passing it to `error`. In essence, we want to+   rewrite `error "undefined!"` to++     let ?stk = pushCallStack <error's location> ?stk+     in error "undefined!"++   We achieve this effect by emitting a NEW wanted++     [W] d :: IP "stk" CallStack++   from which we build the evidence term++     EvCsPushCall "error" <error's location> (EvId d)++   that we use to solve the call to `error`. The new wanted `d` will+   then be solved per rule (1), ie as a regular IP.++   (see GHC.Tc.Solver.Interact.interactDict)++3. We default any insoluble CallStacks to the empty CallStack. Suppose+   `undefined` did not request a CallStack, ie++     undefinedNoStk :: a+     undefinedNoStk = error "undefined!"++   Under the usual IP rules, the new wanted from rule (2) would be+   insoluble as there's no given IP from which to solve it, so we+   would get an "unbound implicit parameter" error.++   We don't ever want to emit an insoluble CallStack IP, so we add a+   defaulting pass to default any remaining wanted CallStacks to the+   empty CallStack with the evidence term++     EvCsEmpty++   (see GHC.Tc.Solver.simpl_top and GHC.Tc.Solver.defaultCallStacks)++This provides a lightweight mechanism for building up call-stacks+explicitly, but is notably limited by the fact that the stack will+stop at the first function whose type does not include a CallStack IP.+For example, using the above definition of `undefined`:++  head :: [a] -> a+  head []    = undefined+  head (x:_) = x++  g = head []++the resulting CallStack will include the call to `undefined` in `head`+and the call to `error` in `undefined`, but *not* the call to `head`+in `g`, because `head` did not explicitly request a CallStack.+++Important Details:+- GHC should NEVER report an insoluble CallStack constraint.++- GHC should NEVER infer a CallStack constraint unless one was requested+  with a partial type signature (See TcType.pickQuantifiablePreds).++- A CallStack (defined in GHC.Stack.Types) is a [(String, SrcLoc)],+  where the String is the name of the binder that is used at the+  SrcLoc. SrcLoc is also defined in GHC.Stack.Types and contains the+  package/module/file name, as well as the full source-span. Both+  CallStack and SrcLoc are kept abstract so only GHC can construct new+  values.++- We will automatically solve any wanted CallStack regardless of the+  name of the IP, i.e.++    f = show (?stk :: CallStack)+    g = show (?loc :: CallStack)++  are both valid. However, we will only push new SrcLocs onto existing+  CallStacks when the IP names match, e.g. in++    head :: (?loc :: CallStack) => [a] -> a+    head [] = error (show (?stk :: CallStack))++  the printed CallStack will NOT include head's call-site. This reflects the+  standard scoping rules of implicit-parameters.++- 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 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`+  (see GHC.Tc.Solver.Interact.interactDict).++  This is a bit shady, but is how we ensure that the new wanted is+  solved like a regular IP.++-}++mkEvCast :: EvExpr -> TcCoercion -> EvTerm+mkEvCast ev lco+  | ASSERT2( tcCoercionRole lco == Representational+           , (vcat [text "Coercion of wrong role passed to mkEvCast:", ppr ev, ppr lco]))+    isTcReflCo lco = EvExpr ev+  | otherwise      = evCast ev lco+++mkEvScSelectors         -- Assume   class (..., D ty, ...) => C a b+  :: Class -> [TcType]  -- C ty1 ty2+  -> [(TcPredType,      -- D ty[ty1/a,ty2/b]+       EvExpr)          -- :: C ty1 ty2 -> D ty[ty1/a,ty2/b]+     ]+mkEvScSelectors cls tys+   = zipWith mk_pr (immSuperClasses cls tys) [0..]+  where+    mk_pr pred i = (pred, Var sc_sel_id `mkTyApps` tys)+      where+        sc_sel_id  = classSCSelId cls i -- Zero-indexed++emptyTcEvBinds :: TcEvBinds+emptyTcEvBinds = EvBinds emptyBag++isEmptyTcEvBinds :: TcEvBinds -> Bool+isEmptyTcEvBinds (EvBinds b)    = isEmptyBag b+isEmptyTcEvBinds (TcEvBinds {}) = panic "isEmptyTcEvBinds"++evTermCoercion_maybe :: EvTerm -> Maybe TcCoercion+-- Applied only to EvTerms of type (s~t)+-- See Note [Coercion evidence terms]+evTermCoercion_maybe ev_term+  | EvExpr e <- ev_term = go e+  | otherwise           = Nothing+  where+    go :: EvExpr -> Maybe TcCoercion+    go (Var v)       = return (mkCoVarCo v)+    go (Coercion co) = return co+    go (Cast tm co)  = do { co' <- go tm+                          ; return (mkCoCast co' co) }+    go _             = Nothing++evTermCoercion :: EvTerm -> TcCoercion+evTermCoercion tm = case evTermCoercion_maybe tm of+                      Just co -> co+                      Nothing -> pprPanic "evTermCoercion" (ppr tm)+++{- *********************************************************************+*                                                                      *+                  Free variables+*                                                                      *+********************************************************************* -}++findNeededEvVars :: EvBindMap -> VarSet -> VarSet+-- Find all the Given evidence needed by seeds,+-- looking transitively through binds+findNeededEvVars ev_binds seeds+  = transCloVarSet also_needs seeds+  where+   also_needs :: VarSet -> VarSet+   also_needs needs = nonDetFoldUniqSet add emptyVarSet needs+     -- It's OK to use nonDetFoldUFM here because we immediately+     -- forget about the ordering by creating a set++   add :: Var -> VarSet -> VarSet+   add v needs+     | Just ev_bind <- lookupEvBind ev_binds v+     , EvBind { eb_is_given = is_given, eb_rhs = rhs } <- ev_bind+     , is_given+     = evVarsOfTerm rhs `unionVarSet` needs+     | otherwise+     = needs++evVarsOfTerm :: EvTerm -> VarSet+evVarsOfTerm (EvExpr e)         = exprSomeFreeVars isEvVar e+evVarsOfTerm (EvTypeable _ ev)  = evVarsOfTypeable ev+evVarsOfTerm (EvFun {})         = emptyVarSet -- See Note [Free vars of EvFun]++evVarsOfTerms :: [EvTerm] -> VarSet+evVarsOfTerms = mapUnionVarSet evVarsOfTerm++evVarsOfTypeable :: EvTypeable -> VarSet+evVarsOfTypeable ev =+  case ev of+    EvTypeableTyCon _ e   -> mapUnionVarSet evVarsOfTerm e+    EvTypeableTyApp e1 e2 -> evVarsOfTerms [e1,e2]+    EvTypeableTrFun e1 e2 -> evVarsOfTerms [e1,e2]+    EvTypeableTyLit e     -> evVarsOfTerm e+++{- Note [Free vars of EvFun]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Finding the free vars of an EvFun is made tricky by the fact the+bindings et_binds may be a mutable variable.  Fortunately, we+can just squeeze by.  Here's how.++* evVarsOfTerm is used only by GHC.Tc.Solver.neededEvVars.+* Each EvBindsVar in an et_binds field of an EvFun is /also/ in the+  ic_binds field of an Implication+* So we can track usage via the processing for that implication,+  (see Note [Tracking redundant constraints] in GHC.Tc.Solver).+  We can ignore usage from the EvFun altogether.++************************************************************************+*                                                                      *+                  Pretty printing+*                                                                      *+************************************************************************+-}++instance Outputable HsWrapper where+  ppr co_fn = pprHsWrapper co_fn (no_parens (text "<>"))++pprHsWrapper :: HsWrapper -> (Bool -> SDoc) -> SDoc+-- With -fprint-typechecker-elaboration, print the wrapper+--   otherwise just print what's inside+-- 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+  = 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+    -- False <=> appears as body of let or lambda+    help it WpHole             = it+    help it (WpCompose f1 f2)  = help (help it f2) f1+    help it (WpFun f1 f2 t1 _) = add_parens $ text "\\(x" <> dcolon <> ppr t1 <> text ")." <+>+                                              help (\_ -> it True <+> help (\_ -> text "x") f1 True) f2 False+    help it (WpCast co)   = add_parens $ sep [it False, nest 2 (text "|>"+                                              <+> pprParendCo co)]+    help it (WpEvApp id)  = no_parens  $ sep [it True, nest 2 (ppr id)]+    help it (WpTyApp ty)  = no_parens  $ sep [it True, text "@" <> pprParendType ty]+    help it (WpEvLam id)  = add_parens $ sep [ text "\\" <> pprLamBndr id <> dot, it False]+    help it (WpTyLam tv)  = add_parens $ sep [text "/\\" <> pprLamBndr tv <> dot, it False]+    help it (WpLet binds) = add_parens $ sep [text "let" <+> braces (ppr binds), it False]++pprLamBndr :: Id -> SDoc+pprLamBndr v = pprBndr LambdaBind v++add_parens, no_parens :: SDoc -> Bool -> SDoc+add_parens d True  = parens d+add_parens d False = d+no_parens d _ = d++instance Outputable TcEvBinds where+  ppr (TcEvBinds v) = ppr v+  ppr (EvBinds bs)  = text "EvBinds" <> braces (vcat (map ppr (bagToList bs)))++instance Outputable EvBindsVar where+  ppr (EvBindsVar { ebv_uniq = u })+     = text "EvBindsVar" <> angleBrackets (ppr u)+  ppr (CoEvBindsVar { ebv_uniq = u })+     = text "CoEvBindsVar" <> angleBrackets (ppr u)++instance Uniquable EvBindsVar where+  getUnique = ebv_uniq++instance Outputable EvBind where+  ppr (EvBind { eb_lhs = v, eb_rhs = e, eb_is_given = is_given })+     = sep [ pp_gw <+> ppr v+           , nest 2 $ equals <+> ppr e ]+     where+       pp_gw = brackets (if is_given then char 'G' else char 'W')+   -- We cheat a bit and pretend EqVars are CoVars for the purposes of pretty printing++instance Outputable EvTerm where+  ppr (EvExpr e)         = ppr e+  ppr (EvTypeable ty ev) = ppr ev <+> dcolon <+> text "Typeable" <+> ppr ty+  ppr (EvFun { et_tvs = tvs, et_given = gs, et_binds = bs, et_body = w })+      = hang (text "\\" <+> sep (map pprLamBndr (tvs ++ gs)) <+> arrow)+           2 (ppr bs $$ ppr w)   -- Not very pretty++instance Outputable EvCallStack where+  ppr EvCsEmpty+    = text "[]"+  ppr (EvCsPushCall name loc tm)+    = ppr (name,loc) <+> text ":" <+> ppr tm++instance Outputable EvTypeable where+  ppr (EvTypeableTyCon ts _)  = text "TyCon" <+> ppr ts+  ppr (EvTypeableTyApp t1 t2) = parens (ppr t1 <+> ppr t2)+  ppr (EvTypeableTrFun t1 t2) = parens (ppr t1 <+> arrow <+> ppr t2)+  ppr (EvTypeableTyLit t1)    = text "TyLit" <> ppr t1+++----------------------------------------------------------------------+-- Helper functions for dealing with IP newtype-dictionaries+----------------------------------------------------------------------++-- | Create a 'Coercion' that unwraps an implicit-parameter or+-- overloaded-label dictionary to expose the underlying value. We+-- expect the 'Type' to have the form `IP sym ty` or `IsLabel sym ty`,+-- and return a 'Coercion' `co :: IP sym ty ~ ty` or+-- `co :: IsLabel sym ty ~ Proxy# sym -> ty`.  See also+-- Note [Type-checking overloaded labels] in GHC.Tc.Gen.Expr.+unwrapIP :: Type -> CoercionR+unwrapIP ty =+  case unwrapNewTyCon_maybe tc of+    Just (_,_,ax) -> mkUnbranchedAxInstCo Representational ax tys []+    Nothing       -> pprPanic "unwrapIP" $+                       text "The dictionary for" <+> quotes (ppr tc)+                         <+> text "is not a newtype!"+  where+  (tc, tys) = splitTyConApp ty++-- | Create a 'Coercion' that wraps a value in an implicit-parameter+-- dictionary. See 'unwrapIP'.+wrapIP :: Type -> CoercionR+wrapIP ty = mkSymCo (unwrapIP ty)++----------------------------------------------------------------------+-- A datatype used to pass information when desugaring quotations+----------------------------------------------------------------------++-- We have to pass a `EvVar` and `Type` into `dsBracket` so that the+-- correct evidence and types are applied to all the TH combinators.+-- This data type bundles them up together with some convenience methods.+--+-- The EvVar is evidence for `Quote m`+-- The Type is a metavariable for `m`+--+data QuoteWrapper = QuoteWrapper EvVar Type deriving Data.Data++quoteWrapperTyVarTy :: QuoteWrapper -> Type+quoteWrapperTyVarTy (QuoteWrapper _ t) = t++-- | Convert the QuoteWrapper into a normal HsWrapper which can be used to+-- apply its contents.+applyQuoteWrapper :: QuoteWrapper -> HsWrapper+applyQuoteWrapper (QuoteWrapper ev_var m_var)+  = mkWpEvVarApps [ev_var] <.> mkWpTyApps [m_var]
+ compiler/GHC/Tc/Types/Origin.hs view
@@ -0,0 +1,647 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE LambdaCase #-}++{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}++-- | Describes the provenance of types as they flow through the type-checker.+-- The datatypes here are mainly used for error message generation.+module GHC.Tc.Types.Origin (+  -- UserTypeCtxt+  UserTypeCtxt(..), pprUserTypeCtxt, isSigMaybe,++  -- SkolemInfo+  SkolemInfo(..), pprSigSkolInfo, pprSkolInfo,++  -- CtOrigin+  CtOrigin(..), exprCtOrigin, lexprCtOrigin, matchesCtOrigin, grhssCtOrigin,+  isVisibleOrigin, toInvisibleOrigin,+  pprCtOrigin, isGivenOrigin++  ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Tc.Utils.TcType++import GHC.Hs++import GHC.Types.Id+import GHC.Core.DataCon+import GHC.Core.ConLike+import GHC.Core.TyCon+import GHC.Core.InstEnv+import GHC.Core.PatSyn++import GHC.Unit.Module+import GHC.Types.Name+import GHC.Types.Name.Reader++import GHC.Types.SrcLoc+import GHC.Data.FastString+import GHC.Utils.Outputable+import GHC.Types.Basic++{- *********************************************************************+*                                                                      *+          UserTypeCtxt+*                                                                      *+********************************************************************* -}++-------------------------------------+-- | UserTypeCtxt describes the origin of the polymorphic type+-- in the places where we need an expression to have that type+data UserTypeCtxt+  = FunSigCtxt      -- Function type signature, when checking the type+                    -- Also used for types in SPECIALISE pragmas+       Name              -- Name of the function+       Bool              -- True <=> report redundant constraints+                            -- This is usually True, but False for+                            --   * Record selectors (not important here)+                            --   * Class and instance methods.  Here+                            --     the code may legitimately be more+                            --     polymorphic than the signature+                            --     generated from the class+                            --     declaration++  | InfSigCtxt Name     -- Inferred type for function+  | ExprSigCtxt         -- Expression type signature+  | KindSigCtxt         -- Kind signature+  | StandaloneKindSigCtxt  -- Standalone kind signature+       Name                -- Name of the type/class+  | TypeAppCtxt         -- Visible type application+  | ConArgCtxt Name     -- Data constructor argument+  | TySynCtxt Name      -- RHS of a type synonym decl+  | PatSynCtxt Name     -- Type sig for a pattern synonym+  | PatSigCtxt          -- Type sig in pattern+                        --   eg  f (x::t) = ...+                        --   or  (x::t, y) = e+  | RuleSigCtxt Name    -- LHS of a RULE forall+                        --    RULE "foo" forall (x :: a -> a). f (Just x) = ...+  | ResSigCtxt          -- Result type sig+                        --      f x :: t = ....+  | ForSigCtxt Name     -- Foreign import or export signature+  | DefaultDeclCtxt     -- Types in a default declaration+  | InstDeclCtxt Bool   -- An instance declaration+                        --    True:  stand-alone deriving+                        --    False: vanilla instance declaration+  | SpecInstCtxt        -- SPECIALISE instance pragma+  | ThBrackCtxt         -- Template Haskell type brackets [t| ... |]+  | GenSigCtxt          -- Higher-rank or impredicative situations+                        -- e.g. (f e) where f has a higher-rank type+                        -- We might want to elaborate this+  | GhciCtxt Bool       -- GHCi command :kind <type>+                        -- The Bool indicates if we are checking the outermost+                        -- type application.+                        -- See Note [Unsaturated type synonyms in GHCi] in+                        -- GHC.Tc.Validity.++  | ClassSCCtxt Name    -- Superclasses of a class+  | SigmaCtxt           -- Theta part of a normal for-all type+                        --      f :: <S> => a -> a+  | DataTyCtxt Name     -- The "stupid theta" part of a data decl+                        --      data <S> => T a = MkT a+  | DerivClauseCtxt     -- A 'deriving' clause+  | TyVarBndrKindCtxt Name  -- The kind of a type variable being bound+  | DataKindCtxt Name   -- The kind of a data/newtype (instance)+  | TySynKindCtxt Name  -- The kind of the RHS of a type synonym+  | TyFamResKindCtxt Name   -- The result kind of a type family++{-+-- Notes re TySynCtxt+-- We allow type synonyms that aren't types; e.g.  type List = []+--+-- If the RHS mentions tyvars that aren't in scope, we'll+-- quantify over them:+--      e.g.    type T = a->a+-- will become  type T = forall a. a->a+--+-- With gla-exts that's right, but for H98 we should complain.+-}+++pprUserTypeCtxt :: UserTypeCtxt -> SDoc+pprUserTypeCtxt (FunSigCtxt n _)  = text "the type signature for" <+> quotes (ppr n)+pprUserTypeCtxt (InfSigCtxt n)    = text "the inferred type for" <+> quotes (ppr n)+pprUserTypeCtxt (RuleSigCtxt n)   = text "a RULE for" <+> quotes (ppr n)+pprUserTypeCtxt ExprSigCtxt       = text "an expression type signature"+pprUserTypeCtxt KindSigCtxt       = text "a kind signature"+pprUserTypeCtxt (StandaloneKindSigCtxt n) = text "a standalone kind signature for" <+> quotes (ppr n)+pprUserTypeCtxt TypeAppCtxt       = text "a type argument"+pprUserTypeCtxt (ConArgCtxt c)    = text "the type of the constructor" <+> quotes (ppr c)+pprUserTypeCtxt (TySynCtxt c)     = text "the RHS of the type synonym" <+> quotes (ppr c)+pprUserTypeCtxt ThBrackCtxt       = text "a Template Haskell quotation [t|...|]"+pprUserTypeCtxt PatSigCtxt        = text "a pattern type signature"+pprUserTypeCtxt ResSigCtxt        = text "a result type signature"+pprUserTypeCtxt (ForSigCtxt n)    = text "the foreign declaration for" <+> quotes (ppr n)+pprUserTypeCtxt DefaultDeclCtxt   = text "a type in a `default' declaration"+pprUserTypeCtxt (InstDeclCtxt False) = text "an instance declaration"+pprUserTypeCtxt (InstDeclCtxt True)  = text "a stand-alone deriving instance declaration"+pprUserTypeCtxt SpecInstCtxt      = text "a SPECIALISE instance pragma"+pprUserTypeCtxt GenSigCtxt        = text "a type expected by the context"+pprUserTypeCtxt (GhciCtxt {})     = text "a type in a GHCi command"+pprUserTypeCtxt (ClassSCCtxt c)   = text "the super-classes of class" <+> quotes (ppr c)+pprUserTypeCtxt SigmaCtxt         = text "the context of a polymorphic type"+pprUserTypeCtxt (DataTyCtxt tc)   = text "the context of the data type declaration for" <+> quotes (ppr tc)+pprUserTypeCtxt (PatSynCtxt n)    = text "the signature for pattern synonym" <+> quotes (ppr n)+pprUserTypeCtxt (DerivClauseCtxt) = text "a `deriving' clause"+pprUserTypeCtxt (TyVarBndrKindCtxt n) = text "the kind annotation on the type variable" <+> quotes (ppr n)+pprUserTypeCtxt (DataKindCtxt n)  = text "the kind annotation on the declaration for" <+> quotes (ppr n)+pprUserTypeCtxt (TySynKindCtxt n) = text "the kind annotation on the declaration for" <+> quotes (ppr n)+pprUserTypeCtxt (TyFamResKindCtxt n) = text "the result kind for" <+> quotes (ppr n)++isSigMaybe :: UserTypeCtxt -> Maybe Name+isSigMaybe (FunSigCtxt n _) = Just n+isSigMaybe (ConArgCtxt n)   = Just n+isSigMaybe (ForSigCtxt n)   = Just n+isSigMaybe (PatSynCtxt n)   = Just n+isSigMaybe _                = Nothing++{-+************************************************************************+*                                                                      *+                SkolemInfo+*                                                                      *+************************************************************************+-}++-- SkolemInfo gives the origin of *given* constraints+--   a) type variables are skolemised+--   b) an implication constraint is generated+data SkolemInfo+  = SigSkol -- A skolem that is created by instantiating+            -- a programmer-supplied type signature+            -- Location of the binding site is on the TyVar+            -- See Note [SigSkol SkolemInfo]+       UserTypeCtxt        -- What sort of signature+       TcType              -- Original type signature (before skolemisation)+       [(Name,TcTyVar)]    -- Maps the original name of the skolemised tyvar+                           -- to its instantiated version++  | SigTypeSkol UserTypeCtxt+                 -- like SigSkol, but when we're kind-checking the *type*+                 -- hence, we have less info++  | ForAllSkol SDoc     -- Bound by a user-written "forall".++  | DerivSkol Type      -- Bound by a 'deriving' clause;+                        -- the type is the instance we are trying to derive++  | InstSkol            -- Bound at an instance decl+  | InstSC TypeSize     -- A "given" constraint obtained by superclass selection.+                        -- If (C ty1 .. tyn) is the largest class from+                        --    which we made a superclass selection in the chain,+                        --    then TypeSize = sizeTypes [ty1, .., tyn]+                        -- See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance++  | 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 GhcRn)+             -- e.g.   data T = forall a. Eq a => MkT a+             --        f (MkT x) = ...+             -- The pattern MkT x will allocate an existential type+             -- variable for 'a'.++  | ArrowSkol           -- An arrow form (see GHC.Tc.Gen.Arrow)++  | IPSkol [HsIPName]   -- Binding site of an implicit parameter++  | RuleSkol RuleName   -- The LHS of a RULE++  | InferSkol [(Name,TcType)]+                        -- We have inferred a type for these (mutually-recursivive)+                        -- polymorphic Ids, and are now checking that their RHS+                        -- constraints are satisfied.++  | BracketSkol         -- Template Haskell bracket++  | UnifyForAllSkol     -- We are unifying two for-all types+       TcType           -- The instantiated type *inside* the forall++  | TyConSkol TyConFlavour Name  -- bound in a type declaration of the given flavour++  | DataConSkol Name    -- bound as an existential in a Haskell98 datacon decl or+                        -- as any variable in a GADT datacon decl++  | ReifySkol           -- Bound during Template Haskell reification++  | 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+  ppr = pprSkolInfo++pprSkolInfo :: SkolemInfo -> SDoc+-- Complete the sentence "is a rigid type variable bound by..."+pprSkolInfo (SigSkol cx ty _) = pprSigSkolInfo cx ty+pprSkolInfo (SigTypeSkol cx)  = pprUserTypeCtxt cx+pprSkolInfo (ForAllSkol doc)  = quotes doc+pprSkolInfo (IPSkol ips)      = text "the implicit-parameter binding" <> plural ips <+> text "for"+                                 <+> pprWithCommas ppr ips+pprSkolInfo (DerivSkol pred)  = text "the deriving clause for" <+> quotes (ppr pred)+pprSkolInfo InstSkol          = text "the instance declaration"+pprSkolInfo (InstSC n)        = text "the instance declaration" <> whenPprDebug (parens (ppr n))+pprSkolInfo FamInstSkol       = text "a family instance declaration"+pprSkolInfo BracketSkol       = text "a Template Haskell bracket"+pprSkolInfo (RuleSkol name)   = text "the RULE" <+> pprRuleName name+pprSkolInfo ArrowSkol         = text "an arrow form"+pprSkolInfo (PatSkol cl mc)   = sep [ pprPatSkolInfo cl+                                    , text "in" <+> pprMatchContext mc ]+pprSkolInfo (InferSkol ids)   = hang (text "the inferred type" <> plural ids <+> text "of")+                                   2 (vcat [ ppr name <+> dcolon <+> ppr ty+                                                   | (name,ty) <- ids ])+pprSkolInfo (UnifyForAllSkol ty) = text "the type" <+> ppr ty+pprSkolInfo (TyConSkol flav name) = text "the" <+> ppr flav <+> text "declaration for" <+> quotes (ppr name)+pprSkolInfo (DataConSkol name)= text "the data constructor" <+> quotes (ppr name)+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.+-- For Insts, these cases should not happen+pprSkolInfo UnkSkol = WARN( True, text "pprSkolInfo: UnkSkol" ) text "UnkSkol"++pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc+-- The type is already tidied+pprSigSkolInfo ctxt ty+  = case ctxt of+       FunSigCtxt f _ -> vcat [ text "the type signature for:"+                              , nest 2 (pprPrefixOcc f <+> dcolon <+> ppr ty) ]+       PatSynCtxt {}  -> pprUserTypeCtxt ctxt  -- See Note [Skolem info for pattern synonyms]+       _              -> vcat [ pprUserTypeCtxt ctxt <> colon+                              , nest 2 (ppr ty) ]++pprPatSkolInfo :: ConLike -> SDoc+pprPatSkolInfo (RealDataCon dc)+  = sep [ text "a pattern with constructor:"+        , nest 2 $ ppr dc <+> dcolon+          <+> pprType (dataConUserType dc) <> comma ]+          -- pprType prints forall's regardless of -fprint-explicit-foralls+          -- which is what we want here, since we might be saying+          -- type variable 't' is bound by ...++pprPatSkolInfo (PatSynCon ps)+  = sep [ text "a pattern with pattern synonym:"+        , nest 2 $ ppr ps <+> dcolon+                   <+> pprPatSynType ps <> comma ]++{- Note [Skolem info for pattern synonyms]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+For pattern synonym SkolemInfo we have+   SigSkol (PatSynCtxt p) ty _+but the type 'ty' is not very helpful.  The full pattern-synonym type+has the provided and required pieces, which it is inconvenient to+record and display here. So we simply don't display the type at all,+contenting outselves with just the name of the pattern synonym, which+is fine.  We could do more, but it doesn't seem worth it.++Note [SigSkol SkolemInfo]+~~~~~~~~~~~~~~~~~~~~~~~~~+Suppose we (deeply) skolemise a type+   f :: forall a. a -> forall b. b -> a+Then we'll instantiate [a :-> a', b :-> b'], and with the instantiated+      a' -> b' -> a.+But when, in an error message, we report that "b is a rigid type+variable bound by the type signature for f", we want to show the foralls+in the right place.  So we proceed as follows:++* In SigSkol we record+    - the original signature forall a. a -> forall b. b -> a+    - the instantiation mapping [a :-> a', b :-> b']++* Then when tidying in GHC.Tc.Utils.TcMType.tidySkolemInfo, we first tidy a' to+  whatever it tidies to, say a''; and then we walk over the type+  replacing the binder a by the tidied version a'', to give+       forall a''. a'' -> forall b''. b'' -> a''+  We need to do this under function arrows, to match what deeplySkolemise+  does.++* Typically a'' will have a nice pretty name like "a", but the point is+  that the foral-bound variables of the signature we report line up with+  the instantiated skolems lying  around in other types.+++************************************************************************+*                                                                      *+            CtOrigin+*                                                                      *+************************************************************************+-}++data CtOrigin+  = GivenOrigin SkolemInfo++  -- All the others are for *wanted* constraints+  | OccurrenceOf Name              -- Occurrence of an overloaded identifier+  | OccurrenceOfRecSel RdrName     -- Occurrence of a record selector+  | AppOrigin                      -- An application of some kind++  | SpecPragOrigin UserTypeCtxt    -- Specialisation pragma for+                                   -- function or instance++  | TypeEqOrigin { uo_actual   :: TcType+                 , uo_expected :: TcType+                 , uo_thing    :: Maybe SDoc+                       -- ^ The thing that has type "actual"+                 , uo_visible  :: Bool+                       -- ^ Is at least one of the three elements above visible?+                       -- (Errors from the polymorphic subsumption check are considered+                       -- visible.) Only used for prioritizing error messages.+                 }++  | KindEqOrigin+      TcType (Maybe TcType)     -- A kind equality arising from unifying these two types+      CtOrigin                  -- originally arising from this+      (Maybe TypeOrKind)        -- the level of the eq this arises from++  | IPOccOrigin  HsIPName       -- Occurrence of an implicit parameter+  | OverLabelOrigin FastString  -- Occurrence of an overloaded label++  | LiteralOrigin (HsOverLit GhcRn)     -- Occurrence of a literal+  | NegateOrigin                        -- Occurrence of syntactic negation++  | ArithSeqOrigin (ArithSeqInfo GhcRn) -- [x..], [x..y] etc+  | AssocFamPatOrigin   -- When matching the patterns of an associated+                        -- family instance with that of its parent class+  | SectionOrigin+  | TupleOrigin         -- (..,..)+  | ExprSigOrigin       -- e :: ty+  | PatSigOrigin        -- p :: ty+  | PatOrigin           -- Instantiating a polytyped pattern at a constructor+  | ProvCtxtOrigin      -- The "provided" context of a pattern synonym signature+        (PatSynBind GhcRn GhcRn) -- Information about the pattern synonym, in+                                 -- particular the name and the right-hand side+  | RecordUpdOrigin+  | ViewPatOrigin++  | ScOrigin TypeSize   -- Typechecking superclasses of an instance declaration+                        -- If the instance head is C ty1 .. tyn+                        --    then TypeSize = sizeTypes [ty1, .., tyn]+                        -- See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance++  | DerivClauseOrigin   -- Typechecking a deriving clause (as opposed to+                        -- standalone deriving).+  | DerivOriginDC DataCon Int Bool+      -- Checking constraints arising from this data con and field index. The+      -- Bool argument in DerivOriginDC and DerivOriginCoerce is True if+      -- standalong deriving (with a wildcard constraint) is being used. This+      -- is used to inform error messages on how to recommended fixes (e.g., if+      -- the argument is True, then don't recommend "use standalone deriving",+      -- but rather "fill in the wildcard constraint yourself").+      -- See Note [Inferring the instance context] in GHC.Tc.Deriv.Infer+  | DerivOriginCoerce Id Type Type Bool+                        -- DerivOriginCoerce id ty1 ty2: Trying to coerce class method `id` from+                        -- `ty1` to `ty2`.+  | StandAloneDerivOrigin -- Typechecking stand-alone deriving. Useful for+                          -- constraints coming from a wildcard constraint,+                          -- e.g., deriving instance _ => Eq (Foo a)+                          -- See Note [Inferring the instance context]+                          -- in GHC.Tc.Deriv.Infer+  | DefaultOrigin       -- Typechecking a default decl+  | DoOrigin            -- Arising from a do expression+  | DoPatOrigin (LPat GhcRn) -- Arising from a failable pattern in+                             -- a do expression+  | MCompOrigin         -- Arising from a monad comprehension+  | MCompPatOrigin (LPat GhcRn) -- Arising from a failable pattern in a+                                -- monad comprehension+  | IfOrigin            -- Arising from an if statement+  | ProcOrigin          -- Arising from a proc expression+  | AnnOrigin           -- An annotation++  | FunDepOrigin1       -- A functional dependency from combining+        PredType CtOrigin RealSrcSpan      -- This constraint arising from ...+        PredType CtOrigin RealSrcSpan      -- and this constraint arising from ...++  | FunDepOrigin2       -- A functional dependency from combining+        PredType CtOrigin   -- This constraint arising from ...+        PredType SrcSpan    -- and this top-level instance+        -- We only need a CtOrigin on the first, because the location+        -- is pinned on the entire error message++  | HoleOrigin+  | UnboundOccurrenceOf OccName+  | ListOrigin          -- An overloaded list+  | BracketOrigin       -- An overloaded quotation bracket+  | StaticOrigin        -- A static form+  | Shouldn'tHappenOrigin String+                            -- the user should never see this one,+                            -- unless ImpredicativeTypes is on, where all+                            -- bets are off+  | InstProvidedOrigin Module ClsInst+        -- Skolem variable arose when we were testing if an instance+        -- is solvable or not.+-- An origin is visible if the place where the constraint arises is manifest+-- in user code. Currently, all origins are visible except for invisible+-- TypeEqOrigins. This is used when choosing which error of+-- several to report+isVisibleOrigin :: CtOrigin -> Bool+isVisibleOrigin (TypeEqOrigin { uo_visible = vis }) = vis+isVisibleOrigin (KindEqOrigin _ _ sub_orig _)       = isVisibleOrigin sub_orig+isVisibleOrigin _                                   = True++-- Converts a visible origin to an invisible one, if possible. Currently,+-- this works only for TypeEqOrigin+toInvisibleOrigin :: CtOrigin -> CtOrigin+toInvisibleOrigin orig@(TypeEqOrigin {}) = orig { uo_visible = False }+toInvisibleOrigin orig                   = orig++isGivenOrigin :: CtOrigin -> Bool+isGivenOrigin (GivenOrigin {})              = True+isGivenOrigin (FunDepOrigin1 _ o1 _ _ o2 _) = isGivenOrigin o1 && isGivenOrigin o2+isGivenOrigin (FunDepOrigin2 _ o1 _ _)      = isGivenOrigin o1+isGivenOrigin _                             = False++instance Outputable CtOrigin where+  ppr = pprCtOrigin++ctoHerald :: SDoc+ctoHerald = text "arising from"++-- | Extract a suitable CtOrigin from a HsExpr+lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin+lexprCtOrigin (L _ e) = exprCtOrigin e++exprCtOrigin :: HsExpr GhcRn -> CtOrigin+exprCtOrigin (HsVar _ (L _ name)) = OccurrenceOf name+exprCtOrigin (HsUnboundVar _ uv)  = UnboundOccurrenceOf uv+exprCtOrigin (HsConLikeOut {})    = panic "exprCtOrigin HsConLikeOut"+exprCtOrigin (HsRecFld _ f)       = OccurrenceOfRecSel (rdrNameAmbiguousFieldOcc f)+exprCtOrigin (HsOverLabel _ _ l)  = OverLabelOrigin l+exprCtOrigin (HsIPVar _ ip)       = IPOccOrigin ip+exprCtOrigin (HsOverLit _ lit)    = LiteralOrigin lit+exprCtOrigin (HsLit {})           = Shouldn'tHappenOrigin "concrete literal"+exprCtOrigin (HsLam _ matches)    = matchesCtOrigin matches+exprCtOrigin (HsLamCase _ ms)     = matchesCtOrigin ms+exprCtOrigin (HsApp _ e1 _)       = lexprCtOrigin e1+exprCtOrigin (HsAppType _ e1 _)   = lexprCtOrigin e1+exprCtOrigin (OpApp _ _ op _)     = lexprCtOrigin op+exprCtOrigin (NegApp _ e _)       = lexprCtOrigin e+exprCtOrigin (HsPar _ e)          = lexprCtOrigin e+exprCtOrigin (SectionL _ _ _)     = SectionOrigin+exprCtOrigin (SectionR _ _ _)     = SectionOrigin+exprCtOrigin (ExplicitTuple {})   = Shouldn'tHappenOrigin "explicit tuple"+exprCtOrigin ExplicitSum{}        = Shouldn'tHappenOrigin "explicit sum"+exprCtOrigin (HsCase _ _ matches) = matchesCtOrigin matches+exprCtOrigin (HsIf _ (SyntaxExprRn syn) _ _ _) = exprCtOrigin syn+exprCtOrigin (HsIf {})           = Shouldn'tHappenOrigin "if expression"+exprCtOrigin (HsMultiIf _ rhs)   = lGRHSCtOrigin rhs+exprCtOrigin (HsLet _ _ e)       = lexprCtOrigin e+exprCtOrigin (HsDo {})           = DoOrigin+exprCtOrigin (ExplicitList {})   = Shouldn'tHappenOrigin "list"+exprCtOrigin (RecordCon {})      = Shouldn'tHappenOrigin "record construction"+exprCtOrigin (RecordUpd {})      = Shouldn'tHappenOrigin "record update"+exprCtOrigin (ExprWithTySig {})  = ExprSigOrigin+exprCtOrigin (ArithSeq {})       = Shouldn'tHappenOrigin "arithmetic sequence"+exprCtOrigin (HsPragE _ _ e)     = lexprCtOrigin e+exprCtOrigin (HsBracket {})      = Shouldn'tHappenOrigin "TH bracket"+exprCtOrigin (HsRnBracketOut {})= Shouldn'tHappenOrigin "HsRnBracketOut"+exprCtOrigin (HsTcBracketOut {})= panic "exprCtOrigin HsTcBracketOut"+exprCtOrigin (HsSpliceE {})      = Shouldn'tHappenOrigin "TH splice"+exprCtOrigin (HsProc {})         = Shouldn'tHappenOrigin "proc"+exprCtOrigin (HsStatic {})       = Shouldn'tHappenOrigin "static expression"+exprCtOrigin (HsTick _ _ e)           = lexprCtOrigin e+exprCtOrigin (HsBinTick _ _ _ e)      = lexprCtOrigin e++-- | Extract a suitable CtOrigin from a MatchGroup+matchesCtOrigin :: MatchGroup GhcRn (LHsExpr GhcRn) -> CtOrigin+matchesCtOrigin (MG { mg_alts = alts })+  | L _ [L _ match] <- alts+  , Match { m_grhss = grhss } <- match+  = grhssCtOrigin grhss++  | otherwise+  = Shouldn'tHappenOrigin "multi-way match"++-- | Extract a suitable CtOrigin from guarded RHSs+grhssCtOrigin :: GRHSs GhcRn (LHsExpr GhcRn) -> CtOrigin+grhssCtOrigin (GRHSs { grhssGRHSs = lgrhss }) = lGRHSCtOrigin lgrhss++-- | Extract a suitable CtOrigin from a list of guarded RHSs+lGRHSCtOrigin :: [LGRHS GhcRn (LHsExpr GhcRn)] -> CtOrigin+lGRHSCtOrigin [L _ (GRHS _ _ (L _ e))] = exprCtOrigin e+lGRHSCtOrigin _ = Shouldn'tHappenOrigin "multi-way GRHS"++pprCtOrigin :: CtOrigin -> SDoc+-- "arising from ..."+-- Not an instance of Outputable because of the "arising from" prefix+pprCtOrigin (GivenOrigin sk) = ctoHerald <+> ppr sk++pprCtOrigin (SpecPragOrigin ctxt)+  = case ctxt of+       FunSigCtxt n _ -> text "for" <+> quotes (ppr n)+       SpecInstCtxt   -> text "a SPECIALISE INSTANCE pragma"+       _              -> text "a SPECIALISE pragma"  -- Never happens I think++pprCtOrigin (FunDepOrigin1 pred1 orig1 loc1 pred2 orig2 loc2)+  = hang (ctoHerald <+> text "a functional dependency between constraints:")+       2 (vcat [ hang (quotes (ppr pred1)) 2 (pprCtOrigin orig1 <+> text "at" <+> ppr loc1)+               , hang (quotes (ppr pred2)) 2 (pprCtOrigin orig2 <+> text "at" <+> ppr loc2) ])++pprCtOrigin (FunDepOrigin2 pred1 orig1 pred2 loc2)+  = hang (ctoHerald <+> text "a functional dependency between:")+       2 (vcat [ hang (text "constraint" <+> quotes (ppr pred1))+                    2 (pprCtOrigin orig1 )+               , hang (text "instance" <+> quotes (ppr pred2))+                    2 (text "at" <+> ppr loc2) ])++pprCtOrigin (KindEqOrigin t1 (Just t2) _ _)+  = hang (ctoHerald <+> text "a kind equality arising from")+       2 (sep [ppr t1, char '~', ppr t2])++pprCtOrigin AssocFamPatOrigin+  = text "when matching a family LHS with its class instance head"++pprCtOrigin (KindEqOrigin t1 Nothing _ _)+  = hang (ctoHerald <+> text "a kind equality when matching")+       2 (ppr t1)++pprCtOrigin (UnboundOccurrenceOf name)+  = ctoHerald <+> text "an undeclared identifier" <+> quotes (ppr name)++pprCtOrigin (DerivOriginDC dc n _)+  = hang (ctoHerald <+> text "the" <+> speakNth n+          <+> text "field of" <+> quotes (ppr dc))+       2 (parens (text "type" <+> quotes (ppr ty)))+  where+    ty = dataConOrigArgTys dc !! (n-1)++pprCtOrigin (DerivOriginCoerce meth ty1 ty2 _)+  = hang (ctoHerald <+> text "the coercion of the method" <+> quotes (ppr meth))+       2 (sep [ text "from type" <+> quotes (ppr ty1)+              , nest 2 $ text "to type" <+> quotes (ppr ty2) ])++pprCtOrigin (DoPatOrigin pat)+    = ctoHerald <+> text "a do statement"+      $$+      text "with the failable pattern" <+> quotes (ppr pat)++pprCtOrigin (MCompPatOrigin pat)+    = ctoHerald <+> hsep [ text "the failable pattern"+           , quotes (ppr pat)+           , text "in a statement in a monad comprehension" ]++pprCtOrigin (Shouldn'tHappenOrigin note)+  = 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")+       2 (text "the signature of" <+> quotes (ppr name))++pprCtOrigin (InstProvidedOrigin mod cls_inst)+  = vcat [ text "arising when attempting to show that"+         , ppr cls_inst+         , text "is provided by" <+> quotes (ppr mod)]++pprCtOrigin simple_origin+  = ctoHerald <+> pprCtO simple_origin++-- | Short one-liners+pprCtO :: CtOrigin -> SDoc+pprCtO (OccurrenceOf name)   = hsep [text "a use of", quotes (ppr name)]+pprCtO (OccurrenceOfRecSel name) = hsep [text "a use of", quotes (ppr name)]+pprCtO AppOrigin             = text "an application"+pprCtO (IPOccOrigin name)    = hsep [text "a use of implicit parameter", quotes (ppr name)]+pprCtO (OverLabelOrigin l)   = hsep [text "the overloaded label"+                                    ,quotes (char '#' <> ppr l)]+pprCtO RecordUpdOrigin       = text "a record update"+pprCtO ExprSigOrigin         = text "an expression type signature"+pprCtO PatSigOrigin          = text "a pattern type signature"+pprCtO PatOrigin             = text "a pattern"+pprCtO ViewPatOrigin         = text "a view pattern"+pprCtO IfOrigin              = text "an if expression"+pprCtO (LiteralOrigin lit)   = hsep [text "the literal", quotes (ppr lit)]+pprCtO (ArithSeqOrigin seq)  = hsep [text "the arithmetic sequence", quotes (ppr seq)]+pprCtO SectionOrigin         = text "an operator section"+pprCtO AssocFamPatOrigin     = text "the LHS of a family instance"+pprCtO TupleOrigin           = text "a tuple"+pprCtO NegateOrigin          = text "a use of syntactic negation"+pprCtO (ScOrigin n)          = text "the superclasses of an instance declaration"+                               <> whenPprDebug (parens (ppr n))+pprCtO DerivClauseOrigin     = text "the 'deriving' clause of a data type declaration"+pprCtO StandAloneDerivOrigin = text "a 'deriving' declaration"+pprCtO DefaultOrigin         = text "a 'default' declaration"+pprCtO DoOrigin              = text "a do statement"+pprCtO MCompOrigin           = text "a statement in a monad comprehension"+pprCtO ProcOrigin            = text "a proc expression"+pprCtO (TypeEqOrigin t1 t2 _ _)= text "a type equality" <+> sep [ppr t1, char '~', ppr t2]+pprCtO AnnOrigin             = text "an annotation"+pprCtO HoleOrigin            = text "a use of" <+> quotes (text "_")+pprCtO ListOrigin            = text "an overloaded list"+pprCtO StaticOrigin          = text "a static form"+pprCtO BracketOrigin         = text "a quotation bracket"+pprCtO _                     = panic "pprCtOrigin"
+ compiler/GHC/Tc/Utils/TcType.hs view
@@ -0,0 +1,2481 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998++-}++{-# LANGUAGE CPP, ScopedTypeVariables, MultiWayIf, FlexibleContexts #-}+{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}++-- | Types used in the typechecker}+--+-- This module provides the Type interface for front-end parts of the+-- compiler.  These parts+--+-- * treat "source types" as opaque:+--         newtypes, and predicates are meaningful.+-- * look through usage types+--+module GHC.Tc.Utils.TcType (+  --------------------------------+  -- Types+  TcType, TcSigmaType, TcRhoType, TcTauType, TcPredType, TcThetaType,+  TcTyVar, TcTyVarSet, TcDTyVarSet, TcTyCoVarSet, TcDTyCoVarSet,+  TcKind, TcCoVar, TcTyCoVar, TcTyVarBinder, TcTyCon,+  KnotTied,++  ExpType(..), InferResult(..), ExpSigmaType, ExpRhoType, mkCheckExpType,++  SyntaxOpType(..), synKnownType, mkSynFunTys,++  -- TcLevel+  TcLevel(..), topTcLevel, pushTcLevel, isTopTcLevel,+  strictlyDeeperThan, sameDepthAs,+  tcTypeLevel, tcTyVarLevel, maxTcLevel,+  promoteSkolem, promoteSkolemX, promoteSkolemsX,+  --------------------------------+  -- MetaDetails+  TcTyVarDetails(..), pprTcTyVarDetails, vanillaSkolemTv, superSkolemTv,+  MetaDetails(Flexi, Indirect), MetaInfo(..),+  isImmutableTyVar, isSkolemTyVar, isMetaTyVar,  isMetaTyVarTy, isTyVarTy,+  tcIsTcTyVar, isTyVarTyVar, isOverlappableTyVar,  isTyConableTyVar,+  isFskTyVar, isFmvTyVar, isFlattenTyVar,+  isAmbiguousTyVar, metaTyVarRef, metaTyVarInfo,+  isFlexi, isIndirect, isRuntimeUnkSkol,+  metaTyVarTcLevel, setMetaTyVarTcLevel, metaTyVarTcLevel_maybe,+  isTouchableMetaTyVar,+  isFloatedTouchableMetaTyVar,+  findDupTyVarTvs, mkTyVarNamePairs,++  --------------------------------+  -- Builders+  mkPhiTy, mkInfSigmaTy, mkSpecSigmaTy, mkSigmaTy,+  mkTcAppTy, mkTcAppTys, mkTcCastTy,++  --------------------------------+  -- Splitters+  -- These are important because they do not look through newtypes+  getTyVar,+  tcSplitForAllTy_maybe,+  tcSplitForAllTys, tcSplitForAllTysSameVis,+  tcSplitPiTys, tcSplitPiTy_maybe, tcSplitForAllVarBndrs,+  tcSplitPhiTy, tcSplitPredFunTy_maybe,+  tcSplitFunTy_maybe, tcSplitFunTys, tcFunArgTy, tcFunResultTy, tcFunResultTyN,+  tcSplitFunTysN,+  tcSplitTyConApp, tcSplitTyConApp_maybe,+  tcTyConAppTyCon, tcTyConAppTyCon_maybe, tcTyConAppArgs,+  tcSplitAppTy_maybe, tcSplitAppTy, tcSplitAppTys, tcRepSplitAppTy_maybe,+  tcRepGetNumAppTys,+  tcGetCastedTyVar_maybe, tcGetTyVar_maybe, tcGetTyVar,+  tcSplitSigmaTy, tcSplitNestedSigmaTys, tcDeepSplitSigmaTy_maybe,++  ---------------------------------+  -- Predicates.+  -- Again, newtypes are opaque+  eqType, eqTypes, nonDetCmpType, nonDetCmpTypes, eqTypeX,+  pickyEqType, tcEqType, tcEqKind, tcEqTypeNoKindCheck, tcEqTypeVis,+  isSigmaTy, isRhoTy, isRhoExpTy, isOverloadedTy,+  isFloatingTy, isDoubleTy, isFloatTy, isIntTy, isWordTy, isStringTy,+  isIntegerTy, isBoolTy, isUnitTy, isCharTy, isCallStackTy, isCallStackPred,+  hasIPPred, isTauTy, isTauTyCon, tcIsTyVarTy, tcIsForAllTy,+  isPredTy, isTyVarClassPred, isTyVarHead, isInsolubleOccursCheck,+  checkValidClsArgs, hasTyVarHead,+  isRigidTy, isAlmostFunctionFree,++  ---------------------------------+  -- Misc type manipulators++  deNoteType,+  orphNamesOfType, orphNamesOfCo,+  orphNamesOfTypes, orphNamesOfCoCon,+  getDFunTyKey, evVarPred,++  ---------------------------------+  -- Predicate types+  mkMinimalBySCs, transSuperClasses,+  pickQuantifiablePreds, pickCapturedPreds,+  immSuperClasses, boxEqPred,+  isImprovementPred,++  -- * Finding type instances+  tcTyFamInsts, tcTyFamInstsAndVis, tcTyConAppTyFamInstsAndVis, isTyFamFree,++  -- * Finding "exact" (non-dead) type variables+  exactTyCoVarsOfType, exactTyCoVarsOfTypes,+  anyRewritableTyVar,++  ---------------------------------+  -- Foreign import and export+  isFFIArgumentTy,     -- :: DynFlags -> Safety -> Type -> Bool+  isFFIImportResultTy, -- :: DynFlags -> Type -> Bool+  isFFIExportResultTy, -- :: Type -> Bool+  isFFIExternalTy,     -- :: Type -> Bool+  isFFIDynTy,          -- :: Type -> Type -> Bool+  isFFIPrimArgumentTy, -- :: DynFlags -> Type -> Bool+  isFFIPrimResultTy,   -- :: DynFlags -> Type -> Bool+  isFFILabelTy,        -- :: Type -> Bool+  isFFITy,             -- :: Type -> Bool+  isFunPtrTy,          -- :: Type -> Bool+  tcSplitIOType_maybe, -- :: Type -> Maybe Type++  --------------------------------+  -- Reexported from Kind+  Kind, tcTypeKind,+  liftedTypeKind,+  constraintKind,+  isLiftedTypeKind, isUnliftedTypeKind, classifiesTypeWithValues,++  --------------------------------+  -- Reexported from Type+  Type, PredType, ThetaType, TyCoBinder,+  ArgFlag(..), AnonArgFlag(..), ForallVisFlag(..),++  mkForAllTy, mkForAllTys, mkTyCoInvForAllTys, mkSpecForAllTys, mkTyCoInvForAllTy,+  mkInvForAllTy, mkInvForAllTys,+  mkVisFunTy, mkVisFunTys, mkInvisFunTy, mkInvisFunTys,+  mkTyConApp, mkAppTy, mkAppTys,+  mkTyConTy, mkTyVarTy, mkTyVarTys,+  mkTyCoVarTy, mkTyCoVarTys,++  isClassPred, isEqPrimPred, isIPPred, isEqPred, isEqPredClass,+  mkClassPred,+  tcSplitDFunTy, tcSplitDFunHead, tcSplitMethodTy,+  isRuntimeRepVar, isKindLevPoly,+  isVisibleBinder, isInvisibleBinder,++  -- Type substitutions+  TCvSubst(..),         -- Representation visible to a few friends+  TvSubstEnv, emptyTCvSubst, mkEmptyTCvSubst,+  zipTvSubst,+  mkTvSubstPrs, notElemTCvSubst, unionTCvSubst,+  getTvSubstEnv, setTvSubstEnv, getTCvInScope, extendTCvInScope,+  extendTCvInScopeList, extendTCvInScopeSet, extendTvSubstAndInScope,+  Type.lookupTyVar, Type.extendTCvSubst, Type.substTyVarBndr,+  Type.extendTvSubst,+  isInScope, mkTCvSubst, mkTvSubst, zipTyEnv, zipCoEnv,+  Type.substTy, substTys, substTyWith, substTyWithCoVars,+  substTyAddInScope,+  substTyUnchecked, substTysUnchecked, substThetaUnchecked,+  substTyWithUnchecked,+  substCoUnchecked, substCoWithUnchecked,+  substTheta,++  isUnliftedType,       -- Source types are always lifted+  isUnboxedTupleType,   -- Ditto+  isPrimitiveType,++  tcView, coreView,++  tyCoVarsOfType, tyCoVarsOfTypes, closeOverKinds,+  tyCoFVsOfType, tyCoFVsOfTypes,+  tyCoVarsOfTypeDSet, tyCoVarsOfTypesDSet, closeOverKindsDSet,+  tyCoVarsOfTypeList, tyCoVarsOfTypesList,+  noFreeVarsOfType,++  --------------------------------+  pprKind, pprParendKind, pprSigmaType,+  pprType, pprParendType, pprTypeApp, pprTyThingCategory, tyThingCategory,+  pprTheta, pprParendTheta, pprThetaArrowTy, pprClassPred,+  pprTCvBndr, pprTCvBndrs,++  TypeSize, sizeType, sizeTypes, scopedSort,++  ---------------------------------+  -- argument visibility+  tcTyConVisibilities, isNextTyConArgVisible, isNextArgVisible++  ) where++#include "HsVersions.h"++-- friends:+import GHC.Prelude++import GHC.Core.TyCo.Rep+import GHC.Core.TyCo.Subst ( mkTvSubst, substTyWithCoVars )+import GHC.Core.TyCo.FVs+import GHC.Core.TyCo.Ppr+import GHC.Core.Class+import GHC.Types.Var+import GHC.Types.ForeignCall+import GHC.Types.Var.Set+import GHC.Core.Coercion+import GHC.Core.Type as Type+import GHC.Core.Predicate+import GHC.Types.RepType+import GHC.Core.TyCon++-- others:+import GHC.Driver.Session+import GHC.Core.FVs+import GHC.Types.Name as Name+            -- We use this to make dictionaries for type literals.+            -- Perhaps there's a better way to do this?+import GHC.Types.Name.Set+import GHC.Types.Var.Env+import GHC.Builtin.Names+import GHC.Builtin.Types ( coercibleClass, eqClass, heqClass, unitTyCon, unitTyConKey+                         , listTyCon, constraintKind )+import GHC.Types.Basic+import GHC.Utils.Misc+import GHC.Data.Maybe+import GHC.Data.List.SetOps ( getNth, findDupsEq )+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Utils.Error( Validity(..), MsgDoc, isValid )+import qualified GHC.LanguageExtensions as LangExt++import Data.List  ( mapAccumL )+-- import Data.Functor.Identity( Identity(..) )+import Data.IORef+import Data.List.NonEmpty( NonEmpty(..) )++{-+************************************************************************+*                                                                      *+              Types+*                                                                      *+************************************************************************++The type checker divides the generic Type world into the+following more structured beasts:++sigma ::= forall tyvars. phi+        -- A sigma type is a qualified type+        --+        -- Note that even if 'tyvars' is empty, theta+        -- may not be: e.g.   (?x::Int) => Int++        -- Note that 'sigma' is in prenex form:+        -- all the foralls are at the front.+        -- A 'phi' type has no foralls to the right of+        -- an arrow++phi :: theta => rho++rho ::= sigma -> rho+     |  tau++-- A 'tau' type has no quantification anywhere+-- Note that the args of a type constructor must be taus+tau ::= tyvar+     |  tycon tau_1 .. tau_n+     |  tau_1 tau_2+     |  tau_1 -> tau_2++-- In all cases, a (saturated) type synonym application is legal,+-- provided it expands to the required form.++Note [TcTyVars and TyVars in the typechecker]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The typechecker uses a lot of type variables with special properties,+notably being a unification variable with a mutable reference.  These+use the 'TcTyVar' variant of Var.Var.++Note, though, that a /bound/ type variable can (and probably should)+be a TyVar.  E.g+    forall a. a -> a+Here 'a' is really just a deBruijn-number; it certainly does not have+a significant TcLevel (as every TcTyVar does).  So a forall-bound type+variable should be TyVars; and hence a TyVar can appear free in a TcType.++The type checker and constraint solver can also encounter /free/ type+variables that use the 'TyVar' variant of Var.Var, for a couple of+reasons:++  - When typechecking a class decl, say+       class C (a :: k) where+          foo :: T a -> Int+    We have first kind-check the header; fix k and (a:k) to be+    TyVars, bring 'k' and 'a' into scope, and kind check the+    signature for 'foo'.  In doing so we call solveEqualities to+    solve any kind equalities in foo's signature.  So the solver+    may see free occurrences of 'k'.++    See calls to tcExtendTyVarEnv for other places that ordinary+    TyVars are bought into scope, and hence may show up in the types+    and kinds generated by GHC.Tc.Gen.HsType.++  - The pattern-match overlap checker calls the constraint solver,+    long after TcTyVars have been zonked away++It's convenient to simply treat these TyVars as skolem constants,+which of course they are.  We give them a level number of "outermost",+so they behave as global constants.  Specifically:++* Var.tcTyVarDetails succeeds on a TyVar, returning+  vanillaSkolemTv, as well as on a TcTyVar.++* tcIsTcTyVar returns True for both TyVar and TcTyVar variants+  of Var.Var.  The "tc" prefix means "a type variable that can be+  encountered by the typechecker".++This is a bit of a change from an earlier era when we remoselessly+insisted on real TcTyVars in the type checker.  But that seems+unnecessary (for skolems, TyVars are fine) and it's now very hard+to guarantee, with the advent of kind equalities.++Note [Coercion variables in free variable lists]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There are several places in the GHC codebase where functions like+tyCoVarsOfType, tyCoVarsOfCt, et al. are used to compute the free type+variables of a type. The "Co" part of these functions' names shouldn't be+dismissed, as it is entirely possible that they will include coercion variables+in addition to type variables! As a result, there are some places in GHC.Tc.Utils.TcType+where we must take care to check that a variable is a _type_ variable (using+isTyVar) before calling tcTyVarDetails--a partial function that is not defined+for coercion variables--on the variable. Failing to do so led to+GHC #12785.+-}++-- See Note [TcTyVars and TyVars in the typechecker]+type TcCoVar = CoVar    -- Used only during type inference+type TcType = Type      -- A TcType can have mutable type variables+type TcTyCoVar = Var    -- Either a TcTyVar or a CoVar+        -- Invariant on ForAllTy in TcTypes:+        --      forall a. T+        -- a cannot occur inside a MutTyVar in T; that is,+        -- T is "flattened" before quantifying over a++type TcTyVarBinder   = TyVarBinder+type TcTyCon         = TyCon   -- these can be the TcTyCon constructor++-- These types do not have boxy type variables in them+type TcPredType     = PredType+type TcThetaType    = ThetaType+type TcSigmaType    = TcType+type TcRhoType      = TcType  -- Note [TcRhoType]+type TcTauType      = TcType+type TcKind         = Kind+type TcTyVarSet     = TyVarSet+type TcTyCoVarSet   = TyCoVarSet+type TcDTyVarSet    = DTyVarSet+type TcDTyCoVarSet  = DTyCoVarSet++{- *********************************************************************+*                                                                      *+          ExpType: an "expected type" in the type checker+*                                                                      *+********************************************************************* -}++-- | An expected type to check against during type-checking.+-- See Note [ExpType] in GHC.Tc.Utils.TcMType, where you'll also find manipulators.+data ExpType = Check TcType+             | Infer !InferResult++data InferResult+  = IR { ir_uniq :: Unique  -- For debugging only++       , ir_lvl  :: TcLevel -- See Note [TcLevel of ExpType] in GHC.Tc.Utils.TcMType++       , ir_ref  :: IORef (Maybe TcType) }+         -- The type that fills in this hole should be a Type,+         -- that is, its kind should be (TYPE rr) for some rr++type ExpSigmaType = ExpType+type ExpRhoType   = ExpType++instance Outputable ExpType where+  ppr (Check ty) = text "Check" <> braces (ppr ty)+  ppr (Infer ir) = ppr ir++instance Outputable InferResult where+  ppr (IR { ir_uniq = u, ir_lvl = lvl })+    = text "Infer" <> braces (ppr u <> comma <> ppr lvl)++-- | Make an 'ExpType' suitable for checking.+mkCheckExpType :: TcType -> ExpType+mkCheckExpType = Check+++{- *********************************************************************+*                                                                      *+          SyntaxOpType+*                                                                      *+********************************************************************* -}++-- | What to expect for an argument to a rebindable-syntax operator.+-- Quite like 'Type', but allows for holes to be filled in by tcSyntaxOp.+-- The callback called from tcSyntaxOp gets a list of types; the meaning+-- of these types is determined by a left-to-right depth-first traversal+-- of the 'SyntaxOpType' tree. So if you pass in+--+-- > SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny+--+-- you'll get three types back: one for the first 'SynAny', the /element/+-- type of the list, and one for the last 'SynAny'. You don't get anything+-- for the 'SynType', because you've said positively that it should be an+-- Int, and so it shall be.+--+-- This is defined here to avoid defining it in GHC.Tc.Gen.Expr boot file.+data SyntaxOpType+  = SynAny     -- ^ Any type+  | SynRho     -- ^ A rho type, deeply skolemised or instantiated as appropriate+  | SynList    -- ^ A list type. You get back the element type of the list+  | SynFun SyntaxOpType SyntaxOpType+               -- ^ A function.+  | SynType ExpType   -- ^ A known type.+infixr 0 `SynFun`++-- | Like 'SynType' but accepts a regular TcType+synKnownType :: TcType -> SyntaxOpType+synKnownType = SynType . mkCheckExpType++-- | Like 'mkFunTys' but for 'SyntaxOpType'+mkSynFunTys :: [SyntaxOpType] -> ExpType -> SyntaxOpType+mkSynFunTys arg_tys res_ty = foldr SynFun (SynType res_ty) arg_tys+++{-+Note [TcRhoType]+~~~~~~~~~~~~~~~~+A TcRhoType has no foralls or contexts at the top, or to the right of an arrow+  YES    (forall a. a->a) -> Int+  NO     forall a. a ->  Int+  NO     Eq a => a -> a+  NO     Int -> forall a. a -> Int+++************************************************************************+*                                                                      *+        TyVarDetails, MetaDetails, MetaInfo+*                                                                      *+************************************************************************++TyVarDetails gives extra info about type variables, used during type+checking.  It's attached to mutable type variables only.+It's knot-tied back to Var.hs.  There is no reason in principle+why Var.hs shouldn't actually have the definition, but it "belongs" here.++Note [Signature skolems]+~~~~~~~~~~~~~~~~~~~~~~~~+A TyVarTv is a specialised variant of TauTv, with the following invariants:++    * A TyVarTv can be unified only with a TyVar,+      not with any other type++    * Its MetaDetails, if filled in, will always be another TyVarTv+      or a SkolemTv++TyVarTvs are only distinguished to improve error messages.+Consider this++  data T (a:k1) = MkT (S a)+  data S (b:k2) = MkS (T b)++When doing kind inference on {S,T} we don't want *skolems* for k1,k2,+because they end up unifying; we want those TyVarTvs again.+++Note [TyVars and TcTyVars during type checking]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The Var type has constructors TyVar and TcTyVar.  They are used+as follows:++* TcTyVar: used /only/ during type checking.  Should never appear+  afterwards.  May contain a mutable field, in the MetaTv case.++* TyVar: is never seen by the constraint solver, except locally+  inside a type like (forall a. [a] ->[a]), where 'a' is a TyVar.+  We instantiate these with TcTyVars before exposing the type+  to the constraint solver.++I have swithered about the latter invariant, excluding TyVars from the+constraint solver.  It's not strictly essential, and indeed+(historically but still there) Var.tcTyVarDetails returns+vanillaSkolemTv for a TyVar.++But ultimately I want to seeparate Type from TcType, and in that case+we would need to enforce the separation.+-}++-- A TyVarDetails is inside a TyVar+-- See Note [TyVars and TcTyVars]+data TcTyVarDetails+  = SkolemTv      -- A skolem+       TcLevel    -- Level of the implication that binds it+                  -- See GHC.Tc.Utils.Unify Note [Deeper level on the left] for+                  --     how this level number is used+       Bool       -- True <=> this skolem type variable can be overlapped+                  --          when looking up instances+                  -- See Note [Binding when looking up instances] in GHC.Core.InstEnv++  | RuntimeUnk    -- Stands for an as-yet-unknown type in the GHCi+                  -- interactive context++  | MetaTv { mtv_info  :: MetaInfo+           , mtv_ref   :: IORef MetaDetails+           , mtv_tclvl :: TcLevel }  -- See Note [TcLevel and untouchable type variables]++vanillaSkolemTv, superSkolemTv :: TcTyVarDetails+-- See Note [Binding when looking up instances] in GHC.Core.InstEnv+vanillaSkolemTv = SkolemTv topTcLevel False  -- Might be instantiated+superSkolemTv   = SkolemTv topTcLevel True   -- Treat this as a completely distinct type+                  -- The choice of level number here is a bit dodgy, but+                  -- topTcLevel works in the places that vanillaSkolemTv is used++instance Outputable TcTyVarDetails where+  ppr = pprTcTyVarDetails++pprTcTyVarDetails :: TcTyVarDetails -> SDoc+-- For debugging+pprTcTyVarDetails (RuntimeUnk {})      = text "rt"+pprTcTyVarDetails (SkolemTv lvl True)  = text "ssk" <> colon <> ppr lvl+pprTcTyVarDetails (SkolemTv lvl False) = text "sk"  <> colon <> ppr lvl+pprTcTyVarDetails (MetaTv { mtv_info = info, mtv_tclvl = tclvl })+  = ppr info <> colon <> ppr tclvl++-----------------------------+data MetaDetails+  = Flexi  -- Flexi type variables unify to become Indirects+  | Indirect TcType++data MetaInfo+   = TauTv         -- This MetaTv is an ordinary unification variable+                   -- A TauTv is always filled in with a tau-type, which+                   -- never contains any ForAlls.++   | TyVarTv       -- A variant of TauTv, except that it should not be+                   --   unified with a type, only with a type variable+                   -- See Note [Signature skolems]++   | FlatMetaTv    -- A flatten meta-tyvar+                   -- It is a meta-tyvar, but it is always untouchable, with level 0+                   -- See Note [The flattening story] in GHC.Tc.Solver.Flatten++   | FlatSkolTv    -- A flatten skolem tyvar+                   -- Just like FlatMetaTv, but is completely "owned" by+                   --   its Given CFunEqCan.+                   -- It is filled in /only/ by unflattenGivens+                   -- See Note [The flattening story] in GHC.Tc.Solver.Flatten++instance Outputable MetaDetails where+  ppr Flexi         = text "Flexi"+  ppr (Indirect ty) = text "Indirect" <+> ppr ty++instance Outputable MetaInfo where+  ppr TauTv         = text "tau"+  ppr TyVarTv       = text "tyv"+  ppr FlatMetaTv    = text "fmv"+  ppr FlatSkolTv    = text "fsk"++{- *********************************************************************+*                                                                      *+                Untouchable type variables+*                                                                      *+********************************************************************* -}++newtype TcLevel = TcLevel Int deriving( Eq, Ord )+  -- See Note [TcLevel and untouchable type variables] for what this Int is+  -- See also Note [TcLevel assignment]++{-+Note [TcLevel and untouchable type variables]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+* Each unification variable (MetaTv)+  and each Implication+  has a level number (of type TcLevel)++* INVARIANTS.  In a tree of Implications,++    (ImplicInv) The level number (ic_tclvl) of an Implication is+                STRICTLY GREATER THAN that of its parent++    (SkolInv)   The level number of the skolems (ic_skols) of an+                Implication is equal to the level of the implication+                itself (ic_tclvl)++    (GivenInv)  The level number of a unification variable appearing+                in the 'ic_given' of an implication I should be+                STRICTLY LESS THAN the ic_tclvl of I++    (WantedInv) The level number of a unification variable appearing+                in the 'ic_wanted' of an implication I should be+                LESS THAN OR EQUAL TO the ic_tclvl of I+                See Note [WantedInv]++* A unification variable is *touchable* if its level number+  is EQUAL TO that of its immediate parent implication,+  and it is a TauTv or TyVarTv (but /not/ FlatMetaTv or FlatSkolTv)++Note [WantedInv]+~~~~~~~~~~~~~~~~+Why is WantedInv important?  Consider this implication, where+the constraint (C alpha[3]) disobeys WantedInv:++   forall[2] a. blah => (C alpha[3])+                        (forall[3] b. alpha[3] ~ b)++We can unify alpha:=b in the inner implication, because 'alpha' is+touchable; but then 'b' has excaped its scope into the outer implication.++Note [Skolem escape prevention]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We only unify touchable unification variables.  Because of+(WantedInv), there can be no occurrences of the variable further out,+so the unification can't cause the skolems to escape. Example:+     data T = forall a. MkT a (a->Int)+     f x (MkT v f) = length [v,x]+We decide (x::alpha), and generate an implication like+      [1]forall a. (a ~ alpha[0])+But we must not unify alpha:=a, because the skolem would escape.++For the cases where we DO want to unify, we rely on floating the+equality.   Example (with same T)+     g x (MkT v f) = x && True+We decide (x::alpha), and generate an implication like+      [1]forall a. (Bool ~ alpha[0])+We do NOT unify directly, bur rather float out (if the constraint+does not mention 'a') to get+      (Bool ~ alpha[0]) /\ [1]forall a.()+and NOW we can unify alpha.++The same idea of only unifying touchables solves another problem.+Suppose we had+   (F Int ~ uf[0])  /\  [1](forall a. C a => F Int ~ beta[1])+In this example, beta is touchable inside the implication. The+first solveSimpleWanteds step leaves 'uf' un-unified. Then we move inside+the implication where a new constraint+       uf  ~  beta+emerges. If we (wrongly) spontaneously solved it to get uf := beta,+the whole implication disappears but when we pop out again we are left with+(F Int ~ uf) which will be unified by our final zonking stage and+uf will get unified *once more* to (F Int).++Note [TcLevel assignment]+~~~~~~~~~~~~~~~~~~~~~~~~~+We arrange the TcLevels like this++   0   Top level+   1   First-level implication constraints+   2   Second-level implication constraints+   ...etc...+-}++maxTcLevel :: TcLevel -> TcLevel -> TcLevel+maxTcLevel (TcLevel a) (TcLevel b) = TcLevel (a `max` b)++topTcLevel :: TcLevel+-- See Note [TcLevel assignment]+topTcLevel = TcLevel 0   -- 0 = outermost level++isTopTcLevel :: TcLevel -> Bool+isTopTcLevel (TcLevel 0) = True+isTopTcLevel _           = False++pushTcLevel :: TcLevel -> TcLevel+-- See Note [TcLevel assignment]+pushTcLevel (TcLevel us) = TcLevel (us + 1)++strictlyDeeperThan :: TcLevel -> TcLevel -> Bool+strictlyDeeperThan (TcLevel tv_tclvl) (TcLevel ctxt_tclvl)+  = tv_tclvl > ctxt_tclvl++sameDepthAs :: TcLevel -> TcLevel -> Bool+sameDepthAs (TcLevel ctxt_tclvl) (TcLevel tv_tclvl)+  = ctxt_tclvl == tv_tclvl   -- NB: invariant ctxt_tclvl >= tv_tclvl+                             --     So <= would be equivalent++checkTcLevelInvariant :: TcLevel -> TcLevel -> Bool+-- Checks (WantedInv) from Note [TcLevel and untouchable type variables]+checkTcLevelInvariant (TcLevel ctxt_tclvl) (TcLevel tv_tclvl)+  = ctxt_tclvl >= tv_tclvl++-- Returns topTcLevel for non-TcTyVars+tcTyVarLevel :: TcTyVar -> TcLevel+tcTyVarLevel tv+  = case tcTyVarDetails tv of+          MetaTv { mtv_tclvl = tv_lvl } -> tv_lvl+          SkolemTv tv_lvl _             -> tv_lvl+          RuntimeUnk                    -> topTcLevel+++tcTypeLevel :: TcType -> TcLevel+-- Max level of any free var of the type+tcTypeLevel ty+  = foldDVarSet add topTcLevel (tyCoVarsOfTypeDSet ty)+  where+    add v lvl+      | isTcTyVar v = lvl `maxTcLevel` tcTyVarLevel v+      | otherwise = lvl++instance Outputable TcLevel where+  ppr (TcLevel us) = ppr us++promoteSkolem :: TcLevel -> TcTyVar -> TcTyVar+promoteSkolem tclvl skol+  | tclvl < tcTyVarLevel skol+  = ASSERT( isTcTyVar skol && isSkolemTyVar skol )+    setTcTyVarDetails skol (SkolemTv tclvl (isOverlappableTyVar skol))++  | otherwise+  = skol++-- | Change the TcLevel in a skolem, extending a substitution+promoteSkolemX :: TcLevel -> TCvSubst -> TcTyVar -> (TCvSubst, TcTyVar)+promoteSkolemX tclvl subst skol+  = ASSERT( isTcTyVar skol && isSkolemTyVar skol )+    (new_subst, new_skol)+  where+    new_skol+      | tclvl < tcTyVarLevel skol+      = setTcTyVarDetails (updateTyVarKind (substTy subst) skol)+                          (SkolemTv tclvl (isOverlappableTyVar skol))+      | otherwise+      = updateTyVarKind (substTy subst) skol+    new_subst = extendTvSubstWithClone subst skol new_skol++promoteSkolemsX :: TcLevel -> TCvSubst -> [TcTyVar] -> (TCvSubst, [TcTyVar])+promoteSkolemsX tclvl = mapAccumL (promoteSkolemX tclvl)++{- *********************************************************************+*                                                                      *+    Finding type family instances+*                                                                      *+************************************************************************+-}++-- | Finds outermost type-family applications occurring in a type,+-- after expanding synonyms.  In the list (F, tys) that is returned+-- we guarantee that tys matches F's arity.  For example, given+--    type family F a :: * -> *    (arity 1)+-- calling tcTyFamInsts on (Maybe (F Int Bool) will return+--     (F, [Int]), not (F, [Int,Bool])+--+-- This is important for its use in deciding termination of type+-- instances (see #11581).  E.g.+--    type instance G [Int] = ...(F Int <big type>)...+-- we don't need to take <big type> into account when asking if+-- the calls on the RHS are smaller than the LHS+tcTyFamInsts :: Type -> [(TyCon, [Type])]+tcTyFamInsts = map (\(_,b,c) -> (b,c)) . tcTyFamInstsAndVis++-- | Like 'tcTyFamInsts', except that the output records whether the+-- type family and its arguments occur as an /invisible/ argument in+-- some type application. This information is useful because it helps GHC know+-- when to turn on @-fprint-explicit-kinds@ during error reporting so that+-- users can actually see the type family being mentioned.+--+-- As an example, consider:+--+-- @+-- class C a+-- data T (a :: k)+-- type family F a :: k+-- instance C (T @(F Int) (F Bool))+-- @+--+-- There are two occurrences of the type family `F` in that `C` instance, so+-- @'tcTyFamInstsAndVis' (C (T \@(F Int) (F Bool)))@ will return:+--+-- @+-- [ ('True',  F, [Int])+-- , ('False', F, [Bool]) ]+-- @+--+-- @F Int@ is paired with 'True' since it appears as an /invisible/ argument+-- to @C@, whereas @F Bool@ is paired with 'False' since it appears an a+-- /visible/ argument to @C@.+--+-- See also @Note [Kind arguments in error messages]@ in "GHC.Tc.Errors".+tcTyFamInstsAndVis :: Type -> [(Bool, TyCon, [Type])]+tcTyFamInstsAndVis = tcTyFamInstsAndVisX False++tcTyFamInstsAndVisX+  :: Bool -- ^ Is this an invisible argument to some type application?+  -> Type -> [(Bool, TyCon, [Type])]+tcTyFamInstsAndVisX = go+  where+    go is_invis_arg ty+      | Just exp_ty <- tcView ty       = go is_invis_arg exp_ty+    go _ (TyVarTy _)                   = []+    go is_invis_arg (TyConApp tc tys)+      | isTypeFamilyTyCon tc+      = [(is_invis_arg, tc, take (tyConArity tc) tys)]+      | otherwise+      = tcTyConAppTyFamInstsAndVisX is_invis_arg tc tys+    go _            (LitTy {})         = []+    go is_invis_arg (ForAllTy bndr ty) = go is_invis_arg (binderType bndr)+                                         ++ go is_invis_arg ty+    go is_invis_arg (FunTy _ ty1 ty2)  = go is_invis_arg ty1+                                         ++ go is_invis_arg ty2+    go is_invis_arg ty@(AppTy _ _)     =+      let (ty_head, ty_args) = splitAppTys ty+          ty_arg_flags       = appTyArgFlags ty_head ty_args+      in go is_invis_arg ty_head+         ++ concat (zipWith (\flag -> go (isInvisibleArgFlag flag))+                            ty_arg_flags ty_args)+    go is_invis_arg (CastTy ty _)      = go is_invis_arg ty+    go _            (CoercionTy _)     = [] -- don't count tyfams in coercions,+                                            -- as they never get normalized,+                                            -- anyway++-- | In an application of a 'TyCon' to some arguments, find the outermost+-- occurrences of type family applications within the arguments. This function+-- will not consider the 'TyCon' itself when checking for type family+-- applications.+--+-- See 'tcTyFamInstsAndVis' for more details on how this works (as this+-- function is called inside of 'tcTyFamInstsAndVis').+tcTyConAppTyFamInstsAndVis :: TyCon -> [Type] -> [(Bool, TyCon, [Type])]+tcTyConAppTyFamInstsAndVis = tcTyConAppTyFamInstsAndVisX False++tcTyConAppTyFamInstsAndVisX+  :: Bool -- ^ Is this an invisible argument to some type application?+  -> TyCon -> [Type] -> [(Bool, TyCon, [Type])]+tcTyConAppTyFamInstsAndVisX is_invis_arg tc tys =+  let (invis_tys, vis_tys) = partitionInvisibleTypes tc tys+  in concat $ map (tcTyFamInstsAndVisX True)         invis_tys+           ++ map (tcTyFamInstsAndVisX is_invis_arg) vis_tys++isTyFamFree :: Type -> Bool+-- ^ Check that a type does not contain any type family applications.+isTyFamFree = null . tcTyFamInsts++anyRewritableTyVar :: Bool    -- Ignore casts and coercions+                   -> EqRel   -- Ambient role+                   -> (EqRel -> TcTyVar -> Bool)+                   -> TcType -> Bool+-- (anyRewritableTyVar ignore_cos pred ty) returns True+--    if the 'pred' returns True of any free TyVar in 'ty'+-- Do not look inside casts and coercions if 'ignore_cos' is True+-- See Note [anyRewritableTyVar must be role-aware]+anyRewritableTyVar ignore_cos role pred ty+  = go role emptyVarSet ty+  where+    -- NB: No need to expand synonyms, because we can find+    -- all free variables of a synonym by looking at its+    -- arguments++    go_tv rl bvs tv | tv `elemVarSet` bvs = False+                    | otherwise           = pred rl tv++    go rl bvs (TyVarTy tv)       = go_tv rl bvs tv+    go _ _     (LitTy {})        = False+    go rl bvs (TyConApp tc tys)  = go_tc rl bvs tc tys+    go rl bvs (AppTy fun arg)    = go rl bvs fun || go NomEq bvs arg+    go rl bvs (FunTy _ arg res)  = go NomEq bvs arg_rep || go NomEq bvs res_rep ||+                                   go rl bvs arg || go rl bvs res+      where arg_rep = getRuntimeRep arg -- forgetting these causes #17024+            res_rep = getRuntimeRep res+    go rl bvs (ForAllTy tv ty)   = go rl (bvs `extendVarSet` binderVar tv) ty+    go rl bvs (CastTy ty co)     = go rl bvs ty || go_co rl bvs co+    go rl bvs (CoercionTy co)    = go_co rl bvs co  -- ToDo: check++    go_tc NomEq  bvs _  tys = any (go NomEq bvs) tys+    go_tc ReprEq bvs tc tys = any (go_arg bvs)+                              (tyConRolesRepresentational tc `zip` tys)++    go_arg bvs (Nominal,          ty) = go NomEq  bvs ty+    go_arg bvs (Representational, ty) = go ReprEq bvs ty+    go_arg _   (Phantom,          _)  = False  -- We never rewrite with phantoms++    go_co rl bvs co+      | ignore_cos = False+      | otherwise  = anyVarSet (go_tv rl bvs) (tyCoVarsOfCo co)+      -- We don't have an equivalent of anyRewritableTyVar for coercions+      -- (at least not yet) so take the free vars and test them++{- Note [anyRewritableTyVar must be role-aware]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+anyRewritableTyVar is used during kick-out from the inert set,+to decide if, given a new equality (a ~ ty), we should kick out+a constraint C.  Rather than gather free variables and see if 'a'+is among them, we instead pass in a predicate; this is just efficiency.++Moreover, consider+  work item:   [G] a ~R f b+  inert item:  [G] b ~R f a+We use anyRewritableTyVar to decide whether to kick out the inert item,+on the grounds that the work item might rewrite it. Well, 'a' is certainly+free in [G] b ~R f a.  But because the role of a type variable ('f' in+this case) is nominal, the work item can't actually rewrite the inert item.+Moreover, if we were to kick out the inert item the exact same situation+would re-occur and we end up with an infinite loop in which each kicks+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 GHC.Tc.Utils.TcType, not in GHC.Core.TyCo.FVs,+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++{-+************************************************************************+*                                                                      *+                Predicates+*                                                                      *+************************************************************************+-}++tcIsTcTyVar :: TcTyVar -> Bool+-- See Note [TcTyVars and TyVars in the typechecker]+tcIsTcTyVar tv = isTyVar tv++isTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool+isTouchableMetaTyVar ctxt_tclvl tv+  | isTyVar tv -- See Note [Coercion variables in free variable lists]+  , MetaTv { mtv_tclvl = tv_tclvl, mtv_info = info } <- tcTyVarDetails tv+  , not (isFlattenInfo info)+  = ASSERT2( checkTcLevelInvariant ctxt_tclvl tv_tclvl,+             ppr tv $$ ppr tv_tclvl $$ ppr ctxt_tclvl )+    tv_tclvl `sameDepthAs` ctxt_tclvl++  | otherwise = False++isFloatedTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool+isFloatedTouchableMetaTyVar ctxt_tclvl tv+  | isTyVar tv -- See Note [Coercion variables in free variable lists]+  , MetaTv { mtv_tclvl = tv_tclvl, mtv_info = info } <- tcTyVarDetails tv+  , not (isFlattenInfo info)+  = tv_tclvl `strictlyDeeperThan` ctxt_tclvl++  | otherwise = False++isImmutableTyVar :: TyVar -> Bool+isImmutableTyVar tv = isSkolemTyVar tv++isTyConableTyVar, isSkolemTyVar, isOverlappableTyVar,+  isMetaTyVar, isAmbiguousTyVar,+  isFmvTyVar, isFskTyVar, isFlattenTyVar :: TcTyVar -> Bool++isTyConableTyVar tv+        -- True of a meta-type variable that can be filled in+        -- with a type constructor application; in particular,+        -- not a TyVarTv+  | isTyVar tv -- See Note [Coercion variables in free variable lists]+  = case tcTyVarDetails tv of+        MetaTv { mtv_info = TyVarTv } -> False+        _                             -> True+  | otherwise = True++isFmvTyVar tv+  = ASSERT2( tcIsTcTyVar tv, ppr tv )+    case tcTyVarDetails tv of+        MetaTv { mtv_info = FlatMetaTv } -> True+        _                                -> False++isFskTyVar tv+  = ASSERT2( tcIsTcTyVar tv, ppr tv )+    case tcTyVarDetails tv of+        MetaTv { mtv_info = FlatSkolTv } -> True+        _                                -> False++-- | True of both given and wanted flatten-skolems (fmv and fsk)+isFlattenTyVar tv+  = ASSERT2( tcIsTcTyVar tv, ppr tv )+    case tcTyVarDetails tv of+        MetaTv { mtv_info = info } -> isFlattenInfo info+        _                          -> False++isSkolemTyVar tv+  = ASSERT2( tcIsTcTyVar tv, ppr tv )+    case tcTyVarDetails tv of+        MetaTv {} -> False+        _other    -> True++isOverlappableTyVar tv+  | isTyVar tv -- See Note [Coercion variables in free variable lists]+  = case tcTyVarDetails tv of+        SkolemTv _ overlappable -> overlappable+        _                       -> False+  | otherwise = False++isMetaTyVar tv+  | isTyVar tv -- See Note [Coercion variables in free variable lists]+  = case tcTyVarDetails tv of+        MetaTv {} -> True+        _         -> False+  | otherwise = False++-- 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+-- 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]+  = case tcTyVarDetails tv of+        MetaTv {}     -> True+        RuntimeUnk {} -> True+        _             -> False+  | otherwise = False++isMetaTyVarTy :: TcType -> Bool+isMetaTyVarTy (TyVarTy tv) = isMetaTyVar tv+isMetaTyVarTy _            = False++metaTyVarInfo :: TcTyVar -> MetaInfo+metaTyVarInfo tv+  = case tcTyVarDetails tv of+      MetaTv { mtv_info = info } -> info+      _ -> pprPanic "metaTyVarInfo" (ppr tv)++isFlattenInfo :: MetaInfo -> Bool+isFlattenInfo FlatMetaTv = True+isFlattenInfo FlatSkolTv = True+isFlattenInfo _          = False++metaTyVarTcLevel :: TcTyVar -> TcLevel+metaTyVarTcLevel tv+  = case tcTyVarDetails tv of+      MetaTv { mtv_tclvl = tclvl } -> tclvl+      _ -> pprPanic "metaTyVarTcLevel" (ppr tv)++metaTyVarTcLevel_maybe :: TcTyVar -> Maybe TcLevel+metaTyVarTcLevel_maybe tv+  = case tcTyVarDetails tv of+      MetaTv { mtv_tclvl = tclvl } -> Just tclvl+      _                            -> Nothing++metaTyVarRef :: TyVar -> IORef MetaDetails+metaTyVarRef tv+  = case tcTyVarDetails tv of+        MetaTv { mtv_ref = ref } -> ref+        _ -> pprPanic "metaTyVarRef" (ppr tv)++setMetaTyVarTcLevel :: TcTyVar -> TcLevel -> TcTyVar+setMetaTyVarTcLevel tv tclvl+  = case tcTyVarDetails tv of+      details@(MetaTv {}) -> setTcTyVarDetails tv (details { mtv_tclvl = tclvl })+      _ -> pprPanic "metaTyVarTcLevel" (ppr tv)++isTyVarTyVar :: Var -> Bool+isTyVarTyVar tv+  = case tcTyVarDetails tv of+        MetaTv { mtv_info = TyVarTv } -> True+        _                             -> False++isFlexi, isIndirect :: MetaDetails -> Bool+isFlexi Flexi = True+isFlexi _     = False++isIndirect (Indirect _) = True+isIndirect _            = False++isRuntimeUnkSkol :: TyVar -> Bool+-- Called only in GHC.Tc.Errors; see Note [Runtime skolems] there+isRuntimeUnkSkol x+  | RuntimeUnk <- tcTyVarDetails x = True+  | otherwise                      = False++mkTyVarNamePairs :: [TyVar] -> [(Name,TyVar)]+-- Just pair each TyVar with its own name+mkTyVarNamePairs tvs = [(tyVarName tv, tv) | tv <- tvs]++findDupTyVarTvs :: [(Name,TcTyVar)] -> [(Name,Name)]+-- If we have [...(x1,tv)...(x2,tv)...]+-- return (x1,x2) in the result list+findDupTyVarTvs prs+  = concatMap mk_result_prs $+    findDupsEq eq_snd prs+  where+    eq_snd (_,tv1) (_,tv2) = tv1 == tv2+    mk_result_prs ((n1,_) :| xs) = map (\(n2,_) -> (n1,n2)) xs++{-+************************************************************************+*                                                                      *+   Tau, sigma and rho+*                                                                      *+************************************************************************+-}++mkSigmaTy :: [TyCoVarBinder] -> [PredType] -> Type -> Type+mkSigmaTy bndrs theta tau = mkForAllTys bndrs (mkPhiTy theta tau)++-- | Make a sigma ty where all type variables are 'Inferred'. That is,+-- they cannot be used with visible type application.+mkInfSigmaTy :: [TyCoVar] -> [PredType] -> Type -> Type+mkInfSigmaTy tyvars theta ty = mkSigmaTy (mkTyCoVarBinders Inferred tyvars) theta ty++-- | Make a sigma ty where all type variables are "specified". That is,+-- they can be used with visible type application+mkSpecSigmaTy :: [TyVar] -> [PredType] -> Type -> Type+mkSpecSigmaTy tyvars preds ty = mkSigmaTy (mkTyCoVarBinders Specified tyvars) preds ty++mkPhiTy :: [PredType] -> Type -> Type+mkPhiTy = mkInvisFunTys++---------------+getDFunTyKey :: Type -> OccName -- Get some string from a type, to be used to+                                -- construct a dictionary function name+getDFunTyKey ty | Just ty' <- coreView ty = getDFunTyKey ty'+getDFunTyKey (TyVarTy tv)            = getOccName tv+getDFunTyKey (TyConApp tc _)         = getOccName tc+getDFunTyKey (LitTy x)               = getDFunTyLitKey x+getDFunTyKey (AppTy fun _)           = getDFunTyKey fun+getDFunTyKey (FunTy {})              = getOccName funTyCon+getDFunTyKey (ForAllTy _ t)          = getDFunTyKey t+getDFunTyKey (CastTy ty _)           = getDFunTyKey ty+getDFunTyKey t@(CoercionTy _)        = pprPanic "getDFunTyKey" (ppr t)++getDFunTyLitKey :: TyLit -> OccName+getDFunTyLitKey (NumTyLit n) = mkOccName Name.varName (show n)+getDFunTyLitKey (StrTyLit n) = mkOccName Name.varName (show n)  -- hm++{- *********************************************************************+*                                                                      *+           Building types+*                                                                      *+********************************************************************* -}++-- ToDo: I think we need Tc versions of these+-- Reason: mkCastTy checks isReflexiveCastTy, which checks+--         for equality; and that has a different answer+--         depending on whether or not Type = Constraint++mkTcAppTys :: Type -> [Type] -> Type+mkTcAppTys = mkAppTys++mkTcAppTy :: Type -> Type -> Type+mkTcAppTy = mkAppTy++mkTcCastTy :: Type -> Coercion -> Type+mkTcCastTy = mkCastTy   -- Do we need a tc version of mkCastTy?++{-+************************************************************************+*                                                                      *+   Expanding and splitting+*                                                                      *+************************************************************************++These tcSplit functions are like their non-Tc analogues, but+        *) they do not look through newtypes++However, they are non-monadic and do not follow through mutable type+variables.  It's up to you to make sure this doesn't matter.+-}++-- | Splits a forall type into a list of 'TyBinder's and the inner type.+-- Always succeeds, even if it returns an empty list.+tcSplitPiTys :: Type -> ([TyBinder], Type)+tcSplitPiTys ty+  = ASSERT( all isTyBinder (fst sty) ) sty+  where sty = splitPiTys ty++-- | Splits a type into a TyBinder and a body, if possible. Panics otherwise+tcSplitPiTy_maybe :: Type -> Maybe (TyBinder, Type)+tcSplitPiTy_maybe ty+  = ASSERT( isMaybeTyBinder sty ) sty+  where+    sty = splitPiTy_maybe ty+    isMaybeTyBinder (Just (t,_)) = isTyBinder t+    isMaybeTyBinder _            = True++tcSplitForAllTy_maybe :: Type -> Maybe (TyVarBinder, Type)+tcSplitForAllTy_maybe ty | Just ty' <- tcView ty = tcSplitForAllTy_maybe ty'+tcSplitForAllTy_maybe (ForAllTy tv ty) = ASSERT( isTyVarBinder tv ) Just (tv, ty)+tcSplitForAllTy_maybe _                = Nothing++-- | Like 'tcSplitPiTys', but splits off only named binders,+-- returning just the tycovars.+tcSplitForAllTys :: Type -> ([TyVar], Type)+tcSplitForAllTys ty+  = ASSERT( all isTyVar (fst sty) ) sty+  where sty = splitForAllTys ty++-- | Like 'tcSplitForAllTys', but only splits a 'ForAllTy' if+-- @'sameVis' argf supplied_argf@ is 'True', where @argf@ is the visibility+-- of the @ForAllTy@'s binder and @supplied_argf@ is the visibility provided+-- as an argument to this function.+tcSplitForAllTysSameVis :: ArgFlag -> Type -> ([TyVar], Type)+tcSplitForAllTysSameVis supplied_argf ty = ASSERT( all isTyVar (fst sty) ) sty+  where sty = splitForAllTysSameVis supplied_argf ty++-- | Like 'tcSplitForAllTys', but splits off only named binders.+tcSplitForAllVarBndrs :: Type -> ([TyVarBinder], Type)+tcSplitForAllVarBndrs ty = ASSERT( all isTyVarBinder (fst sty)) sty+  where sty = splitForAllVarBndrs ty++-- | Is this a ForAllTy with a named binder?+tcIsForAllTy :: Type -> Bool+tcIsForAllTy ty | Just ty' <- tcView ty = tcIsForAllTy ty'+tcIsForAllTy (ForAllTy {}) = True+tcIsForAllTy _             = False++tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)+-- Split off the first predicate argument from a type+tcSplitPredFunTy_maybe ty+  | Just ty' <- tcView ty = tcSplitPredFunTy_maybe ty'+tcSplitPredFunTy_maybe (FunTy { ft_af = InvisArg+                              , ft_arg = arg, ft_res = res })+  = Just (arg, res)+tcSplitPredFunTy_maybe _+  = Nothing++tcSplitPhiTy :: Type -> (ThetaType, Type)+tcSplitPhiTy ty+  = split ty []+  where+    split ty ts+      = case tcSplitPredFunTy_maybe ty of+          Just (pred, ty) -> split ty (pred:ts)+          Nothing         -> (reverse ts, ty)++-- | Split a sigma type into its parts.+tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)+tcSplitSigmaTy ty = case tcSplitForAllTys ty of+                        (tvs, rho) -> case tcSplitPhiTy rho of+                                        (theta, tau) -> (tvs, theta, tau)++-- | Split a sigma type into its parts, going underneath as many @ForAllTy@s+-- as possible. For example, given this type synonym:+--+-- @+-- type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t+-- @+--+-- if you called @tcSplitSigmaTy@ on this type:+--+-- @+-- forall s t a b. Each s t a b => Traversal s t a b+-- @+--+-- then it would return @([s,t,a,b], [Each s t a b], Traversal s t a b)@. But+-- if you instead called @tcSplitNestedSigmaTys@ on the type, it would return+-- @([s,t,a,b,f], [Each s t a b, Applicative f], (a -> f b) -> s -> f t)@.+tcSplitNestedSigmaTys :: Type -> ([TyVar], ThetaType, Type)+-- NB: This is basically a pure version of deeplyInstantiate (from Inst) that+-- doesn't compute an HsWrapper.+tcSplitNestedSigmaTys ty+    -- If there's a forall, split it apart and try splitting the rho type+    -- underneath it.+  | Just (arg_tys, tvs1, theta1, rho1) <- tcDeepSplitSigmaTy_maybe ty+  = let (tvs2, theta2, rho2) = tcSplitNestedSigmaTys rho1+    in (tvs1 ++ tvs2, theta1 ++ theta2, mkVisFunTys arg_tys rho2)+    -- If there's no forall, we're done.+  | otherwise = ([], [], ty)++-----------------------+tcDeepSplitSigmaTy_maybe+  :: TcSigmaType -> Maybe ([TcType], [TyVar], ThetaType, TcSigmaType)+-- Looks for a *non-trivial* quantified type, under zero or more function arrows+-- By "non-trivial" we mean either tyvars or constraints are non-empty++tcDeepSplitSigmaTy_maybe ty+  | Just (arg_ty, res_ty)           <- tcSplitFunTy_maybe ty+  , Just (arg_tys, tvs, theta, rho) <- tcDeepSplitSigmaTy_maybe res_ty+  = Just (arg_ty:arg_tys, tvs, theta, rho)++  | (tvs, theta, rho) <- tcSplitSigmaTy ty+  , not (null tvs && null theta)+  = Just ([], tvs, theta, rho)++  | otherwise = Nothing++-----------------------+tcTyConAppTyCon :: Type -> TyCon+tcTyConAppTyCon ty+  = case tcTyConAppTyCon_maybe ty of+      Just tc -> tc+      Nothing -> pprPanic "tcTyConAppTyCon" (pprType ty)++-- | Like 'tcRepSplitTyConApp_maybe', but only returns the 'TyCon'.+tcTyConAppTyCon_maybe :: Type -> Maybe TyCon+tcTyConAppTyCon_maybe ty+  | Just ty' <- tcView ty = tcTyConAppTyCon_maybe ty'+tcTyConAppTyCon_maybe (TyConApp tc _)+  = Just tc+tcTyConAppTyCon_maybe (FunTy { ft_af = VisArg })+  = Just funTyCon  -- (=>) is /not/ a TyCon in its own right+                   -- C.f. tcRepSplitAppTy_maybe+tcTyConAppTyCon_maybe _+  = Nothing++tcTyConAppArgs :: Type -> [Type]+tcTyConAppArgs ty = case tcSplitTyConApp_maybe ty of+                        Just (_, args) -> args+                        Nothing        -> pprPanic "tcTyConAppArgs" (pprType ty)++tcSplitTyConApp :: Type -> (TyCon, [Type])+tcSplitTyConApp ty = case tcSplitTyConApp_maybe ty of+                        Just stuff -> stuff+                        Nothing    -> pprPanic "tcSplitTyConApp" (pprType ty)++-----------------------+tcSplitFunTys :: Type -> ([Type], Type)+tcSplitFunTys ty = case tcSplitFunTy_maybe ty of+                        Nothing        -> ([], ty)+                        Just (arg,res) -> (arg:args, res')+                                       where+                                          (args,res') = tcSplitFunTys res++tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)+tcSplitFunTy_maybe ty+  | Just ty' <- tcView ty = tcSplitFunTy_maybe ty'+tcSplitFunTy_maybe (FunTy { ft_af = af, ft_arg = arg, ft_res = res })+  | VisArg <- af = Just (arg, res)+tcSplitFunTy_maybe _ = Nothing+        -- Note the VisArg guard+        -- Consider     (?x::Int) => Bool+        -- We don't want to treat this as a function type!+        -- A concrete example is test tc230:+        --      f :: () -> (?p :: ()) => () -> ()+        --+        --      g = f () ()++tcSplitFunTysN :: Arity                      -- n: Number of desired args+               -> TcRhoType+               -> Either Arity               -- Number of missing arrows+                        ([TcSigmaType],      -- Arg types (always N types)+                         TcSigmaType)        -- The rest of the type+-- ^ Split off exactly the specified number argument types+-- Returns+--  (Left m) if there are 'm' missing arrows in the type+--  (Right (tys,res)) if the type looks like t1 -> ... -> tn -> res+tcSplitFunTysN n ty+ | n == 0+ = Right ([], ty)+ | Just (arg,res) <- tcSplitFunTy_maybe ty+ = case tcSplitFunTysN (n-1) res of+     Left m            -> Left m+     Right (args,body) -> Right (arg:args, body)+ | otherwise+ = Left n++tcSplitFunTy :: Type -> (Type, Type)+tcSplitFunTy  ty = expectJust "tcSplitFunTy" (tcSplitFunTy_maybe ty)++tcFunArgTy :: Type -> Type+tcFunArgTy    ty = fst (tcSplitFunTy ty)++tcFunResultTy :: Type -> Type+tcFunResultTy ty = snd (tcSplitFunTy ty)++-- | Strips off n *visible* arguments and returns the resulting type+tcFunResultTyN :: HasDebugCallStack => Arity -> Type -> Type+tcFunResultTyN n ty+  | Right (_, res_ty) <- tcSplitFunTysN n ty+  = res_ty+  | otherwise+  = pprPanic "tcFunResultTyN" (ppr n <+> ppr ty)++-----------------------+tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)+tcSplitAppTy_maybe ty | Just ty' <- tcView ty = tcSplitAppTy_maybe ty'+tcSplitAppTy_maybe ty = tcRepSplitAppTy_maybe ty++tcSplitAppTy :: Type -> (Type, Type)+tcSplitAppTy ty = case tcSplitAppTy_maybe ty of+                    Just stuff -> stuff+                    Nothing    -> pprPanic "tcSplitAppTy" (pprType ty)++tcSplitAppTys :: Type -> (Type, [Type])+tcSplitAppTys ty+  = go ty []+  where+    go ty args = case tcSplitAppTy_maybe ty of+                   Just (ty', arg) -> go ty' (arg:args)+                   Nothing         -> (ty,args)++-- | Returns the number of arguments in the given type, without+-- looking through synonyms. This is used only for error reporting.+-- We don't look through synonyms because of #11313.+tcRepGetNumAppTys :: Type -> Arity+tcRepGetNumAppTys = length . snd . repSplitAppTys++-----------------------+-- | If the type is a tyvar, possibly under a cast, returns it, along+-- with the coercion. Thus, the co is :: kind tv ~N kind type+tcGetCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)+tcGetCastedTyVar_maybe ty | Just ty' <- tcView ty = tcGetCastedTyVar_maybe ty'+tcGetCastedTyVar_maybe (CastTy (TyVarTy tv) co) = Just (tv, co)+tcGetCastedTyVar_maybe (TyVarTy tv)             = Just (tv, mkNomReflCo (tyVarKind tv))+tcGetCastedTyVar_maybe _                        = Nothing++tcGetTyVar_maybe :: Type -> Maybe TyVar+tcGetTyVar_maybe ty | Just ty' <- tcView ty = tcGetTyVar_maybe ty'+tcGetTyVar_maybe (TyVarTy tv)   = Just tv+tcGetTyVar_maybe _              = Nothing++tcGetTyVar :: String -> Type -> TyVar+tcGetTyVar msg ty+  = case tcGetTyVar_maybe ty of+     Just tv -> tv+     Nothing -> pprPanic msg (ppr ty)++tcIsTyVarTy :: Type -> Bool+tcIsTyVarTy ty | Just ty' <- tcView ty = tcIsTyVarTy ty'+tcIsTyVarTy (CastTy ty _) = tcIsTyVarTy ty  -- look through casts, as+                                            -- this is only used for+                                            -- e.g., FlexibleContexts+tcIsTyVarTy (TyVarTy _)   = True+tcIsTyVarTy _             = False++-----------------------+tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type])+-- Split the type of a dictionary function+-- We don't use tcSplitSigmaTy,  because a DFun may (with NDP)+-- have non-Pred arguments, such as+--     df :: forall m. (forall b. Eq b => Eq (m b)) -> C m+--+-- Also NB splitFunTys, not tcSplitFunTys;+-- the latter specifically stops at PredTy arguments,+-- and we don't want to do that here+tcSplitDFunTy ty+  = case tcSplitForAllTys ty   of { (tvs, rho)    ->+    case splitFunTys rho       of { (theta, tau)  ->+    case tcSplitDFunHead tau   of { (clas, tys)   ->+    (tvs, theta, clas, tys) }}}++tcSplitDFunHead :: Type -> (Class, [Type])+tcSplitDFunHead = getClassPredTys++tcSplitMethodTy :: Type -> ([TyVar], PredType, Type)+-- A class method (selector) always has a type like+--   forall as. C as => blah+-- So if the class looks like+--   class C a where+--     op :: forall b. (Eq a, Ix b) => a -> b+-- the class method type looks like+--  op :: forall a. C a => forall b. (Eq a, Ix b) => a -> b+--+-- tcSplitMethodTy just peels off the outer forall and+-- that first predicate+tcSplitMethodTy ty+  | (sel_tyvars,sel_rho) <- tcSplitForAllTys ty+  , Just (first_pred, local_meth_ty) <- tcSplitPredFunTy_maybe sel_rho+  = (sel_tyvars, first_pred, local_meth_ty)+  | otherwise+  = pprPanic "tcSplitMethodTy" (ppr ty)+++{- *********************************************************************+*                                                                      *+            Type equalities+*                                                                      *+********************************************************************* -}++tcEqKind :: HasDebugCallStack => TcKind -> TcKind -> Bool+tcEqKind = tcEqType++tcEqType :: HasDebugCallStack => TcType -> TcType -> Bool+-- tcEqType is a proper implements the same Note [Non-trivial definitional+-- equality] (in GHC.Core.TyCo.Rep) as `eqType`, but Type.eqType believes (* ==+-- Constraint), and that is NOT what we want in the type checker!+tcEqType ty1 ty2+  =  tc_eq_type False False ki1 ki2+  && tc_eq_type False False ty1 ty2+  where+    ki1 = tcTypeKind ty1+    ki2 = tcTypeKind ty2++-- | Just like 'tcEqType', but will return True for types of different kinds+-- as long as their non-coercion structure is identical.+tcEqTypeNoKindCheck :: TcType -> TcType -> Bool+tcEqTypeNoKindCheck ty1 ty2+  = tc_eq_type False False ty1 ty2++-- | Like 'tcEqType', but returns True if the /visible/ part of the types+-- are equal, even if they are really unequal (in the invisible bits)+tcEqTypeVis :: TcType -> TcType -> Bool+tcEqTypeVis ty1 ty2 = tc_eq_type False True ty1 ty2++-- | Like 'pickyEqTypeVis', but returns a Bool for convenience+pickyEqType :: TcType -> TcType -> Bool+-- Check when two types _look_ the same, _including_ synonyms.+-- So (pickyEqType String [Char]) returns False+-- This ignores kinds and coercions, because this is used only for printing.+pickyEqType ty1 ty2 = tc_eq_type True False ty1 ty2++++-- | Real worker for 'tcEqType'. No kind check!+tc_eq_type :: Bool          -- ^ True <=> do not expand type synonyms+           -> Bool          -- ^ True <=> compare visible args only+           -> Type -> Type+           -> Bool+-- Flags False, False is the usual setting for tc_eq_type+tc_eq_type keep_syns vis_only orig_ty1 orig_ty2+  = go orig_env orig_ty1 orig_ty2+  where+    go :: RnEnv2 -> Type -> Type -> Bool+    go env t1 t2 | not keep_syns, Just t1' <- tcView t1 = go env t1' t2+    go env t1 t2 | not keep_syns, Just t2' <- tcView t2 = go env t1 t2'++    go env (TyVarTy tv1) (TyVarTy tv2)+      = rnOccL env tv1 == rnOccR env tv2++    go _   (LitTy lit1) (LitTy lit2)+      = lit1 == lit2++    go env (ForAllTy (Bndr tv1 vis1) ty1)+           (ForAllTy (Bndr tv2 vis2) ty2)+      =  vis1 == vis2+      && (vis_only || go env (varType tv1) (varType tv2))+      && go (rnBndr2 env tv1 tv2) ty1 ty2++    -- Make sure we handle all FunTy cases since falling through to the+    -- AppTy case means that tcRepSplitAppTy_maybe may see an unzonked+    -- kind variable, which causes things to blow up.+    go env (FunTy _ arg1 res1) (FunTy _ arg2 res2)+      = go env arg1 arg2 && go env res1 res2+    go env ty (FunTy _ arg res) = eqFunTy env arg res ty+    go env (FunTy _ arg res) ty = eqFunTy env arg res ty++      -- See Note [Equality on AppTys] in GHC.Core.Type+    go env (AppTy s1 t1)        ty2+      | Just (s2, t2) <- tcRepSplitAppTy_maybe ty2+      = go env s1 s2 && go env t1 t2+    go env ty1                  (AppTy s2 t2)+      | Just (s1, t1) <- tcRepSplitAppTy_maybe ty1+      = go env s1 s2 && go env t1 t2++    go env (TyConApp tc1 ts1)   (TyConApp tc2 ts2)+      = tc1 == tc2 && gos env (tc_vis tc1) ts1 ts2++    go env (CastTy t1 _)   t2              = go env t1 t2+    go env t1              (CastTy t2 _)   = go env t1 t2+    go _   (CoercionTy {}) (CoercionTy {}) = True++    go _ _ _ = False++    gos _   _         []       []      = True+    gos env (ig:igs) (t1:ts1) (t2:ts2) = (ig || go env t1 t2)+                                      && gos env igs ts1 ts2+    gos _ _ _ _ = False++    tc_vis :: TyCon -> [Bool]  -- True for the fields we should ignore+    tc_vis tc | vis_only  = inviss ++ repeat False    -- Ignore invisibles+              | otherwise = repeat False              -- Ignore nothing+       -- The repeat False is necessary because tycons+       -- can legitimately be oversaturated+      where+        bndrs = tyConBinders tc+        inviss  = map isInvisibleTyConBinder bndrs++    orig_env = mkRnEnv2 $ mkInScopeSet $ tyCoVarsOfTypes [orig_ty1, orig_ty2]++    -- @eqFunTy arg res ty@ is True when @ty@ equals @FunTy arg res@. This is+    -- sometimes hard to know directly because @ty@ might have some casts+    -- obscuring the FunTy. And 'splitAppTy' is difficult because we can't+    -- always extract a RuntimeRep (see Note [xyz]) if the kind of the arg or+    -- res is unzonked/unflattened. Thus this function, which handles this+    -- corner case.+    eqFunTy :: RnEnv2 -> Type -> Type -> Type -> Bool+               -- Last arg is /not/ FunTy+    eqFunTy env arg res ty@(AppTy{}) = get_args ty []+      where+        get_args :: Type -> [Type] -> Bool+        get_args (AppTy f x)       args = get_args f (x:args)+        get_args (CastTy t _)      args = get_args t args+        get_args (TyConApp tc tys) args+          | tc == funTyCon+          , [_, _, arg', res'] <- tys ++ args+          = go env arg arg' && go env res res'+        get_args _ _    = False+    eqFunTy _ _ _ _     = False++{- *********************************************************************+*                                                                      *+                       Predicate types+*                                                                      *+************************************************************************++Deconstructors and tests on predicate types++Note [Kind polymorphic type classes]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+    class C f where...   -- C :: forall k. k -> Constraint+    g :: forall (f::*). C f => f -> f++Here the (C f) in the signature is really (C * f), and we+don't want to complain that the * isn't a type variable!+-}++isTyVarClassPred :: PredType -> Bool+isTyVarClassPred ty = case getClassPredTys_maybe ty of+    Just (_, tys) -> all isTyVarTy tys+    _             -> False++-------------------------+checkValidClsArgs :: Bool -> Class -> [KindOrType] -> Bool+-- If the Bool is True (flexible contexts), return True (i.e. ok)+-- Otherwise, check that the type (not kind) args are all headed by a tyvar+--   E.g. (Eq a) accepted, (Eq (f a)) accepted, but (Eq Int) rejected+-- This function is here rather than in GHC.Tc.Validity because it is+-- called from GHC.Tc.Solver, which itself is imported by GHC.Tc.Validity+checkValidClsArgs flexible_contexts cls kts+  | flexible_contexts = True+  | otherwise         = all hasTyVarHead tys+  where+    tys = filterOutInvisibleTypes (classTyCon cls) kts++hasTyVarHead :: Type -> Bool+-- Returns true of (a t1 .. tn), where 'a' is a type variable+hasTyVarHead ty                 -- Haskell 98 allows predicates of form+  | tcIsTyVarTy ty = True       --      C (a ty1 .. tyn)+  | otherwise                   -- where a is a type variable+  = case tcSplitAppTy_maybe ty of+       Just (ty, _) -> hasTyVarHead ty+       Nothing      -> False++evVarPred :: EvVar -> PredType+evVarPred var = varType var+  -- Historical note: I used to have an ASSERT here,+  -- checking (isEvVarType (varType var)).  But with something like+  --   f :: c => _ -> _+  -- we end up with (c :: kappa), and (kappa ~ Constraint).  Until+  -- we solve and zonk (which there is no particular reason to do for+  -- partial signatures, (isEvVarType kappa) will return False. But+  -- nothing is wrong.  So I just removed the ASSERT.++------------------+-- | When inferring types, should we quantify over a given predicate?+-- Generally true of classes; generally false of equality constraints.+-- Equality constraints that mention quantified type variables and+-- implicit variables complicate the story. See Notes+-- [Inheriting implicit parameters] and [Quantifying over equality constraints]+pickQuantifiablePreds+  :: TyVarSet           -- Quantifying over these+  -> TcThetaType        -- Proposed constraints to quantify+  -> TcThetaType        -- A subset that we can actually quantify+-- This function decides whether a particular constraint should be+-- quantified over, given the type variables that are being quantified+pickQuantifiablePreds qtvs theta+  = let flex_ctxt = True in  -- Quantify over non-tyvar constraints, even without+                             -- -XFlexibleContexts: see #10608, #10351+         -- flex_ctxt <- xoptM Opt_FlexibleContexts+    mapMaybe (pick_me flex_ctxt) theta+  where+    pick_me flex_ctxt pred+      = case classifyPredType pred of++          ClassPred cls tys+            | Just {} <- isCallStackPred cls tys+              -- NEVER infer a CallStack constraint.  Otherwise we let+              -- the constraints bubble up to be solved from the outer+              -- context, or be defaulted when we reach the top-level.+              -- See Note [Overview of implicit CallStacks]+            -> Nothing++            | isIPClass cls+            -> Just pred -- See note [Inheriting implicit parameters]++            | pick_cls_pred flex_ctxt cls tys+            -> Just pred++          EqPred eq_rel ty1 ty2+            | quantify_equality eq_rel ty1 ty2+            , Just (cls, tys) <- boxEqPred eq_rel ty1 ty2+              -- boxEqPred: See Note [Lift equality constraints when quantifying]+            , pick_cls_pred flex_ctxt cls tys+            -> Just (mkClassPred cls tys)++          IrredPred ty+            | tyCoVarsOfType ty `intersectsVarSet` qtvs+            -> Just pred++          _ -> Nothing+++    pick_cls_pred flex_ctxt cls tys+      = tyCoVarsOfTypes tys `intersectsVarSet` qtvs+        && (checkValidClsArgs flex_ctxt cls tys)+           -- Only quantify over predicates that checkValidType+           -- will pass!  See #10351.++    -- See Note [Quantifying over equality constraints]+    quantify_equality NomEq  ty1 ty2 = quant_fun ty1 || quant_fun ty2+    quantify_equality ReprEq _   _   = True++    quant_fun ty+      = case tcSplitTyConApp_maybe ty of+          Just (tc, tys) | isTypeFamilyTyCon tc+                         -> tyCoVarsOfTypes tys `intersectsVarSet` qtvs+          _ -> False++boxEqPred :: EqRel -> Type -> Type -> Maybe (Class, [Type])+-- Given (t1 ~# t2) or (t1 ~R# t2) return the boxed version+--       (t1 ~ t2)  or (t1 `Coercible` t2)+boxEqPred eq_rel ty1 ty2+  = case eq_rel of+      NomEq  | homo_kind -> Just (eqClass,        [k1,     ty1, ty2])+             | otherwise -> Just (heqClass,       [k1, k2, ty1, ty2])+      ReprEq | homo_kind -> Just (coercibleClass, [k1,     ty1, ty2])+             | otherwise -> Nothing -- Sigh: we do not have hererogeneous Coercible+                                    --       so we can't abstract over it+                                    -- Nothing fundamental: we could add it+ where+   k1 = tcTypeKind ty1+   k2 = tcTypeKind ty2+   homo_kind = k1 `tcEqType` k2++pickCapturedPreds+  :: TyVarSet           -- Quantifying over these+  -> TcThetaType        -- Proposed constraints to quantify+  -> TcThetaType        -- A subset that we can actually quantify+-- A simpler version of pickQuantifiablePreds, used to winnow down+-- the inferred constraints of a group of bindings, into those for+-- one particular identifier+pickCapturedPreds qtvs theta+  = filter captured theta+  where+    captured pred = isIPPred pred || (tyCoVarsOfType pred `intersectsVarSet` qtvs)+++-- Superclasses++type PredWithSCs a = (PredType, [PredType], a)++mkMinimalBySCs :: forall a. (a -> PredType) -> [a] -> [a]+-- Remove predicates that+--+--   - are the same as another predicate+--+--   - can be deduced from another by superclasses,+--+--   - are a reflexive equality (e.g  * ~ *)+--     (see Note [Remove redundant provided dicts] in GHC.Tc.TyCl.PatSyn)+--+-- The result is a subset of the input.+-- The 'a' is just paired up with the PredType;+--   typically it might be a dictionary Id+mkMinimalBySCs get_pred xs = go preds_with_scs []+ where+   preds_with_scs :: [PredWithSCs a]+   preds_with_scs = [ (pred, pred : transSuperClasses pred, x)+                    | x <- xs+                    , let pred = get_pred x ]++   go :: [PredWithSCs a]   -- Work list+      -> [PredWithSCs a]   -- Accumulating result+      -> [a]+   go [] min_preds+     = reverse (map thdOf3 min_preds)+       -- The 'reverse' isn't strictly necessary, but it+       -- means that the results are returned in the same+       -- order as the input, which is generally saner+   go (work_item@(p,_,_) : work_list) min_preds+     | EqPred _ t1 t2 <- classifyPredType p+     , t1 `tcEqType` t2   -- See GHC.Tc.TyCl.PatSyn+                          -- Note [Remove redundant provided dicts]+     = go work_list min_preds+     | p `in_cloud` work_list || p `in_cloud` min_preds+     = go work_list min_preds+     | otherwise+     = go work_list (work_item : min_preds)++   in_cloud :: PredType -> [PredWithSCs a] -> Bool+   in_cloud p ps = or [ p `tcEqType` p' | (_, scs, _) <- ps, p' <- scs ]++transSuperClasses :: PredType -> [PredType]+-- (transSuperClasses p) returns (p's superclasses) not including p+-- Stop if you encounter the same class again+-- See Note [Expanding superclasses]+transSuperClasses p+  = go emptyNameSet p+  where+    go :: NameSet -> PredType -> [PredType]+    go rec_clss p+       | ClassPred cls tys <- classifyPredType p+       , let cls_nm = className cls+       , not (cls_nm `elemNameSet` rec_clss)+       , let rec_clss' | isCTupleClass cls = rec_clss+                       | otherwise         = rec_clss `extendNameSet` cls_nm+       = [ p' | sc <- immSuperClasses cls tys+              , p'  <- sc : go rec_clss' sc ]+       | otherwise+       = []++immSuperClasses :: Class -> [Type] -> [PredType]+immSuperClasses cls tys+  = substTheta (zipTvSubst tyvars tys) sc_theta+  where+    (tyvars,sc_theta,_,_) = classBigSig cls++isImprovementPred :: PredType -> Bool+-- Either it's an equality, or has some functional dependency+isImprovementPred ty+  = case classifyPredType ty of+      EqPred NomEq t1 t2 -> not (t1 `tcEqType` t2)+      EqPred ReprEq _ _  -> False+      ClassPred cls _    -> classHasFds cls+      IrredPred {}       -> True -- Might have equalities after reduction?+      ForAllPred {}      -> False++-- | Is the equality+--        a ~r ...a....+-- definitely insoluble or not?+--      a ~r Maybe a      -- Definitely insoluble+--      a ~N ...(F a)...  -- Not definitely insoluble+--                        -- Perhaps (F a) reduces to Int+--      a ~R ...(N a)...  -- Not definitely insoluble+--                        -- Perhaps newtype N a = MkN Int+-- See Note [Occurs check error] in+-- GHC.Tc.Solver.Canonical for the motivation for this function.+isInsolubleOccursCheck :: EqRel -> TcTyVar -> TcType -> Bool+isInsolubleOccursCheck eq_rel tv ty+  = go ty+  where+    go ty | Just ty' <- tcView ty = go ty'+    go (TyVarTy tv') = tv == tv' || go (tyVarKind tv')+    go (LitTy {})    = False+    go (AppTy t1 t2) = case eq_rel of  -- See Note [AppTy and ReprEq]+                         NomEq  -> go t1 || go t2+                         ReprEq -> go t1+    go (FunTy _ t1 t2) = go t1 || go t2+    go (ForAllTy (Bndr tv' _) inner_ty)+      | tv' == tv = False+      | otherwise = go (varType tv') || go inner_ty+    go (CastTy ty _)  = go ty   -- ToDo: what about the coercion+    go (CoercionTy _) = False   -- ToDo: what about the coercion+    go (TyConApp tc tys)+      | isGenerativeTyCon tc role = any go tys+      | otherwise                 = any go (drop (tyConArity tc) tys)+         -- (a ~ F b a), where F has arity 1,+         -- has an insoluble occurs check++    role = eqRelRole eq_rel++{- Note [Expanding superclasses]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When we expand superclasses, we use the following algorithm:++transSuperClasses( C tys ) returns the transitive superclasses+                           of (C tys), not including C itself++For example+  class C a b => D a b+  class D b a => C a b++Then+  transSuperClasses( Ord ty )  = [Eq ty]+  transSuperClasses( C ta tb ) = [D tb ta, C tb ta]++Notice that in the recursive-superclass case we include C again at+the end of the chain.  One could exclude C in this case, but+the code is more awkward and there seems no good reason to do so.+(However C.f. GHC.Tc.Solver.Canonical.mk_strict_superclasses, which /does/+appear to do so.)++The algorithm is expand( so_far, pred ):++ 1. If pred is not a class constraint, return empty set+       Otherwise pred = C ts+ 2. If C is in so_far, return empty set (breaks loops)+ 3. Find the immediate superclasses constraints of (C ts)+ 4. For each such sc_pred, return (sc_pred : expand( so_far+C, D ss )++Notice that++ * With normal Haskell-98 classes, the loop-detector will never bite,+   so we'll get all the superclasses.++ * We need the loop-breaker in case we have UndecidableSuperClasses on++ * Since there is only a finite number of distinct classes, expansion+   must terminate.++ * The loop breaking is a bit conservative. Notably, a tuple class+   could contain many times without threatening termination:+      (Eq a, (Ord a, Ix a))+   And this is try of any class that we can statically guarantee+   as non-recursive (in some sense).  For now, we just make a special+   case for tuples.  Something better would be cool.++See also GHC.Tc.TyCl.Utils.checkClassCycles.++Note [Lift equality constraints when quantifying]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We can't quantify over a constraint (t1 ~# t2) because that isn't a+predicate type; see Note [Types for coercions, predicates, and evidence]+in GHC.Core.TyCo.Rep.++So we have to 'lift' it to (t1 ~ t2).  Similarly (~R#) must be lifted+to Coercible.++This tiresome lifting is the reason that pick_me (in+pickQuantifiablePreds) returns a Maybe rather than a Bool.++Note [Quantifying over equality constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Should we quantify over an equality constraint (s ~ t)?  In general, we don't.+Doing so may simply postpone a type error from the function definition site to+its call site.  (At worst, imagine (Int ~ Bool)).++However, consider this+         forall a. (F [a] ~ Int) => blah+Should we quantify over the (F [a] ~ Int)?  Perhaps yes, because at the call+site we will know 'a', and perhaps we have instance  F [Bool] = Int.+So we *do* quantify over a type-family equality where the arguments mention+the quantified variables.++Note [Inheriting implicit parameters]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider this:++        f x = (x::Int) + ?y++where f is *not* a top-level binding.+From the RHS of f we'll get the constraint (?y::Int).+There are two types we might infer for f:++        f :: Int -> Int++(so we get ?y from the context of f's definition), or++        f :: (?y::Int) => Int -> Int++At first you might think the first was better, because then+?y behaves like a free variable of the definition, rather than+having to be passed at each call site.  But of course, the WHOLE+IDEA is that ?y should be passed at each call site (that's what+dynamic binding means) so we'd better infer the second.++BOTTOM LINE: when *inferring types* you must quantify over implicit+parameters, *even if* they don't mention the bound type variables.+Reason: because implicit parameters, uniquely, have local instance+declarations. See pickQuantifiablePreds.++Note [Quantifying over equality constraints]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Should we quantify over an equality constraint (s ~ t)?  In general, we don't.+Doing so may simply postpone a type error from the function definition site to+its call site.  (At worst, imagine (Int ~ Bool)).++However, consider this+         forall a. (F [a] ~ Int) => blah+Should we quantify over the (F [a] ~ Int).  Perhaps yes, because at the call+site we will know 'a', and perhaps we have instance  F [Bool] = Int.+So we *do* quantify over a type-family equality where the arguments mention+the quantified variables.++************************************************************************+*                                                                      *+      Classifying types+*                                                                      *+************************************************************************+-}++isSigmaTy :: TcType -> Bool+-- isSigmaTy returns true of any qualified type.  It doesn't+-- *necessarily* have any foralls.  E.g+--        f :: (?x::Int) => Int -> Int+isSigmaTy ty | Just ty' <- tcView ty = isSigmaTy ty'+isSigmaTy (ForAllTy {})                = True+isSigmaTy (FunTy { ft_af = InvisArg }) = True+isSigmaTy _                            = False++isRhoTy :: TcType -> Bool   -- True of TcRhoTypes; see Note [TcRhoType]+isRhoTy ty | Just ty' <- tcView ty = isRhoTy ty'+isRhoTy (ForAllTy {})                          = False+isRhoTy (FunTy { ft_af = VisArg, ft_res = r }) = isRhoTy r+isRhoTy _                                      = True++-- | Like 'isRhoTy', but also says 'True' for 'Infer' types+isRhoExpTy :: ExpType -> Bool+isRhoExpTy (Check ty) = isRhoTy ty+isRhoExpTy (Infer {}) = True++isOverloadedTy :: Type -> Bool+-- Yes for a type of a function that might require evidence-passing+-- Used only by bindLocalMethods+isOverloadedTy ty | Just ty' <- tcView ty = isOverloadedTy ty'+isOverloadedTy (ForAllTy _  ty)             = isOverloadedTy ty+isOverloadedTy (FunTy { ft_af = InvisArg }) = True+isOverloadedTy _                            = False++isFloatTy, isDoubleTy, isIntegerTy, isIntTy, isWordTy, isBoolTy,+    isUnitTy, isCharTy, isAnyTy :: Type -> Bool+isFloatTy      = is_tc floatTyConKey+isDoubleTy     = is_tc doubleTyConKey+isIntegerTy    = is_tc integerTyConKey+isIntTy        = is_tc intTyConKey+isWordTy       = is_tc wordTyConKey+isBoolTy       = is_tc boolTyConKey+isUnitTy       = is_tc unitTyConKey+isCharTy       = is_tc charTyConKey+isAnyTy        = is_tc anyTyConKey++-- | Does a type represent a floating-point number?+isFloatingTy :: Type -> Bool+isFloatingTy ty = isFloatTy ty || isDoubleTy ty++-- | Is a type 'String'?+isStringTy :: Type -> Bool+isStringTy ty+  = case tcSplitTyConApp_maybe ty of+      Just (tc, [arg_ty]) -> tc == listTyCon && isCharTy arg_ty+      _                   -> False++-- | Is a type a 'CallStack'?+isCallStackTy :: Type -> Bool+isCallStackTy ty+  | Just tc <- tyConAppTyCon_maybe ty+  = tc `hasKey` callStackTyConKey+  | otherwise+  = False++-- | Is a 'PredType' a 'CallStack' implicit parameter?+--+-- If so, return the name of the parameter.+isCallStackPred :: Class -> [Type] -> Maybe FastString+isCallStackPred cls tys+  | [ty1, ty2] <- tys+  , isIPClass cls+  , isCallStackTy ty2+  = isStrLitTy ty1+  | otherwise+  = Nothing++is_tc :: Unique -> Type -> Bool+-- Newtypes are opaque to this+is_tc uniq ty = case tcSplitTyConApp_maybe ty of+                        Just (tc, _) -> uniq == getUnique tc+                        Nothing      -> False++-- | Does the given tyvar appear at the head of a chain of applications+--     (a t1 ... tn)+isTyVarHead :: TcTyVar -> TcType -> Bool+isTyVarHead tv (TyVarTy tv')   = tv == tv'+isTyVarHead tv (AppTy fun _)   = isTyVarHead tv fun+isTyVarHead tv (CastTy ty _)   = isTyVarHead tv ty+isTyVarHead _ (TyConApp {})    = False+isTyVarHead _  (LitTy {})      = False+isTyVarHead _  (ForAllTy {})   = False+isTyVarHead _  (FunTy {})      = False+isTyVarHead _  (CoercionTy {}) = False+++{- Note [AppTy and ReprEq]+~~~~~~~~~~~~~~~~~~~~~~~~~~+Consider   a ~R# b a+           a ~R# a b++The former is /not/ a definite error; we might instantiate 'b' with Id+   newtype Id a = MkId a+but the latter /is/ a definite error.++On the other hand, with nominal equality, both are definite errors+-}++isRigidTy :: TcType -> Bool+isRigidTy ty+  | Just (tc,_) <- tcSplitTyConApp_maybe ty = isGenerativeTyCon tc Nominal+  | Just {} <- tcSplitAppTy_maybe ty        = True+  | isForAllTy ty                           = True+  | otherwise                               = False+++-- | Is this type *almost function-free*? See Note [Almost function-free]+-- in GHC.Tc.Types+isAlmostFunctionFree :: TcType -> Bool+isAlmostFunctionFree ty | Just ty' <- tcView ty = isAlmostFunctionFree ty'+isAlmostFunctionFree (TyVarTy {})    = True+isAlmostFunctionFree (AppTy ty1 ty2) = isAlmostFunctionFree ty1 &&+                                       isAlmostFunctionFree ty2+isAlmostFunctionFree (TyConApp tc args)+  | isTypeFamilyTyCon tc = False+  | otherwise            = all isAlmostFunctionFree args+isAlmostFunctionFree (ForAllTy bndr _) = isAlmostFunctionFree (binderType bndr)+isAlmostFunctionFree (FunTy _ ty1 ty2) = isAlmostFunctionFree ty1 &&+                                         isAlmostFunctionFree ty2+isAlmostFunctionFree (LitTy {})        = True+isAlmostFunctionFree (CastTy ty _)     = isAlmostFunctionFree ty+isAlmostFunctionFree (CoercionTy {})   = True++{-+************************************************************************+*                                                                      *+   Misc+*                                                                      *+************************************************************************++Note [Visible type application]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+GHC implements a generalisation of the algorithm described in the+"Visible Type Application" paper (available from+http://www.cis.upenn.edu/~sweirich/publications.html). A key part+of that algorithm is to distinguish user-specified variables from inferred+variables. For example, the following should typecheck:++  f :: forall a b. a -> b -> b+  f = const id++  g = const id++  x = f @Int @Bool 5 False+  y = g 5 @Bool False++The idea is that we wish to allow visible type application when we are+instantiating a specified, fixed variable. In practice, specified, fixed+variables are either written in a type signature (or+annotation), OR are imported from another module. (We could do better here,+for example by doing SCC analysis on parts of a module and considering any+type from outside one's SCC to be fully specified, but this is very confusing to+users. The simple rule above is much more straightforward and predictable.)++So, both of f's quantified variables are specified and may be instantiated.+But g has no type signature, so only id's variable is specified (because id+is imported). We write the type of g as forall {a}. a -> forall b. b -> b.+Note that the a is in braces, meaning it cannot be instantiated with+visible type application.++Tracking specified vs. inferred variables is done conveniently by a field+in TyBinder.++-}++deNoteType :: Type -> Type+-- Remove all *outermost* type synonyms and other notes+deNoteType ty | Just ty' <- coreView ty = deNoteType ty'+deNoteType ty = ty++{-+Find the free tycons and classes of a type.  This is used in the front+end of the compiler.+-}++{-+************************************************************************+*                                                                      *+   External types+*                                                                      *+************************************************************************++The compiler's foreign function interface supports the passing of a+restricted set of types as arguments and results (the restricting factor+being the )+-}++tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type)+-- (tcSplitIOType_maybe t) returns Just (IO,t',co)+--              if co : t ~ IO t'+--              returns Nothing otherwise+tcSplitIOType_maybe ty+  = case tcSplitTyConApp_maybe ty of+        Just (io_tycon, [io_res_ty])+         | io_tycon `hasKey` ioTyConKey ->+            Just (io_tycon, io_res_ty)+        _ ->+            Nothing++isFFITy :: Type -> Bool+-- True for any TyCon that can possibly be an arg or result of an FFI call+isFFITy ty = isValid (checkRepTyCon legalFFITyCon ty)++isFFIArgumentTy :: DynFlags -> Safety -> Type -> Validity+-- Checks for valid argument type for a 'foreign import'+isFFIArgumentTy dflags safety ty+   = checkRepTyCon (legalOutgoingTyCon dflags safety) ty++isFFIExternalTy :: Type -> Validity+-- Types that are allowed as arguments of a 'foreign export'+isFFIExternalTy ty = checkRepTyCon legalFEArgTyCon ty++isFFIImportResultTy :: DynFlags -> Type -> Validity+isFFIImportResultTy dflags ty+  = checkRepTyCon (legalFIResultTyCon dflags) ty++isFFIExportResultTy :: Type -> Validity+isFFIExportResultTy ty = checkRepTyCon legalFEResultTyCon ty++isFFIDynTy :: Type -> Type -> Validity+-- The type in a foreign import dynamic must be Ptr, FunPtr, or a newtype of+-- either, and the wrapped function type must be equal to the given type.+-- We assume that all types have been run through normaliseFfiType, so we don't+-- need to worry about expanding newtypes here.+isFFIDynTy expected ty+    -- Note [Foreign import dynamic]+    -- In the example below, expected would be 'CInt -> IO ()', while ty would+    -- be 'FunPtr (CDouble -> IO ())'.+    | Just (tc, [ty']) <- splitTyConApp_maybe ty+    , tyConUnique tc `elem` [ptrTyConKey, funPtrTyConKey]+    , eqType ty' expected+    = IsValid+    | otherwise+    = NotValid (vcat [ text "Expected: Ptr/FunPtr" <+> pprParendType expected <> comma+                     , text "  Actual:" <+> ppr ty ])++isFFILabelTy :: Type -> Validity+-- The type of a foreign label must be Ptr, FunPtr, or a newtype of either.+isFFILabelTy ty = checkRepTyCon ok ty+  where+    ok tc | tc `hasKey` funPtrTyConKey || tc `hasKey` ptrTyConKey+          = IsValid+          | otherwise+          = NotValid (text "A foreign-imported address (via &foo) must have type (Ptr a) or (FunPtr a)")++isFFIPrimArgumentTy :: DynFlags -> Type -> Validity+-- Checks for valid argument type for a 'foreign import prim'+-- Currently they must all be simple unlifted types, or the well-known type+-- Any, which can be used to pass the address to a Haskell object on the heap to+-- the foreign function.+isFFIPrimArgumentTy dflags ty+  | isAnyTy ty = IsValid+  | otherwise  = checkRepTyCon (legalFIPrimArgTyCon dflags) ty++isFFIPrimResultTy :: DynFlags -> Type -> Validity+-- Checks for valid result type for a 'foreign import prim' Currently+-- it must be an unlifted type, including unboxed tuples, unboxed+-- sums, or the well-known type Any.+isFFIPrimResultTy dflags ty+  | isAnyTy ty = IsValid+  | otherwise = checkRepTyCon (legalFIPrimResultTyCon dflags) ty++isFunPtrTy :: Type -> Bool+isFunPtrTy ty+  | Just (tc, [_]) <- splitTyConApp_maybe ty+  = tc `hasKey` funPtrTyConKey+  | otherwise+  = False++-- normaliseFfiType gets run before checkRepTyCon, so we don't+-- need to worry about looking through newtypes or type functions+-- here; that's already been taken care of.+checkRepTyCon :: (TyCon -> Validity) -> Type -> Validity+checkRepTyCon check_tc ty+  = case splitTyConApp_maybe ty of+      Just (tc, tys)+        | isNewTyCon tc -> NotValid (hang msg 2 (mk_nt_reason tc tys $$ nt_fix))+        | otherwise     -> case check_tc tc of+                             IsValid        -> IsValid+                             NotValid extra -> NotValid (msg $$ extra)+      Nothing -> NotValid (quotes (ppr ty) <+> text "is not a data type")+  where+    msg = quotes (ppr ty) <+> text "cannot be marshalled in a foreign call"+    mk_nt_reason tc tys+      | null tys  = text "because its data constructor is not in scope"+      | otherwise = text "because the data constructor for"+                    <+> quotes (ppr tc) <+> text "is not in scope"+    nt_fix = text "Possible fix: import the data constructor to bring it into scope"++{-+Note [Foreign import dynamic]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A dynamic stub must be of the form 'FunPtr ft -> ft' where ft is any foreign+type.  Similarly, a wrapper stub must be of the form 'ft -> IO (FunPtr ft)'.++We use isFFIDynTy to check whether a signature is well-formed. For example,+given a (illegal) declaration like:++foreign import ccall "dynamic"+  foo :: FunPtr (CDouble -> IO ()) -> CInt -> IO ()++isFFIDynTy will compare the 'FunPtr' type 'CDouble -> IO ()' with the curried+result type 'CInt -> IO ()', and return False, as they are not equal.+++----------------------------------------------+These chaps do the work; they are not exported+----------------------------------------------+-}++legalFEArgTyCon :: TyCon -> Validity+legalFEArgTyCon tc+  -- It's illegal to make foreign exports that take unboxed+  -- arguments.  The RTS API currently can't invoke such things.  --SDM 7/2000+  = boxedMarshalableTyCon tc++legalFIResultTyCon :: DynFlags -> TyCon -> Validity+legalFIResultTyCon dflags tc+  | tc == unitTyCon         = IsValid+  | otherwise               = marshalableTyCon dflags tc++legalFEResultTyCon :: TyCon -> Validity+legalFEResultTyCon tc+  | tc == unitTyCon         = IsValid+  | otherwise               = boxedMarshalableTyCon tc++legalOutgoingTyCon :: DynFlags -> Safety -> TyCon -> Validity+-- Checks validity of types going from Haskell -> external world+legalOutgoingTyCon dflags _ tc+  = marshalableTyCon dflags tc++legalFFITyCon :: TyCon -> Validity+-- True for any TyCon that can possibly be an arg or result of an FFI call+legalFFITyCon tc+  | isUnliftedTyCon tc = IsValid+  | tc == unitTyCon    = IsValid+  | otherwise          = boxedMarshalableTyCon tc++marshalableTyCon :: DynFlags -> TyCon -> Validity+marshalableTyCon dflags tc+  | isUnliftedTyCon tc+  , not (isUnboxedTupleTyCon tc || isUnboxedSumTyCon tc)+  , not (null (tyConPrimRep tc)) -- Note [Marshalling void]+  = validIfUnliftedFFITypes dflags+  | otherwise+  = boxedMarshalableTyCon tc++boxedMarshalableTyCon :: TyCon -> Validity+boxedMarshalableTyCon tc+   | getUnique tc `elem` [ intTyConKey, int8TyConKey, int16TyConKey+                         , int32TyConKey, int64TyConKey+                         , wordTyConKey, word8TyConKey, word16TyConKey+                         , word32TyConKey, word64TyConKey+                         , floatTyConKey, doubleTyConKey+                         , ptrTyConKey, funPtrTyConKey+                         , charTyConKey+                         , stablePtrTyConKey+                         , boolTyConKey+                         ]+  = IsValid++  | otherwise = NotValid empty++legalFIPrimArgTyCon :: DynFlags -> TyCon -> Validity+-- Check args of 'foreign import prim', only allow simple unlifted types.+-- Strictly speaking it is unnecessary to ban unboxed tuples and sums here since+-- currently they're of the wrong kind to use in function args anyway.+legalFIPrimArgTyCon dflags tc+  | isUnliftedTyCon tc+  , not (isUnboxedTupleTyCon tc || isUnboxedSumTyCon tc)+  = validIfUnliftedFFITypes dflags+  | otherwise+  = NotValid unlifted_only++legalFIPrimResultTyCon :: DynFlags -> TyCon -> Validity+-- Check result type of 'foreign import prim'. Allow simple unlifted+-- types and also unboxed tuple and sum result types.+legalFIPrimResultTyCon dflags tc+  | isUnliftedTyCon tc+  , isUnboxedTupleTyCon tc || isUnboxedSumTyCon tc+     || not (null (tyConPrimRep tc))   -- Note [Marshalling void]+  = validIfUnliftedFFITypes dflags++  | otherwise+  = NotValid unlifted_only++unlifted_only :: MsgDoc+unlifted_only = text "foreign import prim only accepts simple unlifted types"++validIfUnliftedFFITypes :: DynFlags -> Validity+validIfUnliftedFFITypes dflags+  | xopt LangExt.UnliftedFFITypes dflags =  IsValid+  | otherwise = NotValid (text "To marshal unlifted types, use UnliftedFFITypes")++{-+Note [Marshalling void]+~~~~~~~~~~~~~~~~~~~~~~~+We don't treat State# (whose PrimRep is VoidRep) as marshalable.+In turn that means you can't write+        foreign import foo :: Int -> State# RealWorld++Reason: the back end falls over with panic "primRepHint:VoidRep";+        and there is no compelling reason to permit it+-}++{-+************************************************************************+*                                                                      *+        The "Paterson size" of a type+*                                                                      *+************************************************************************+-}++{-+Note [Paterson conditions on PredTypes]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We are considering whether *class* constraints terminate+(see Note [Paterson conditions]). Precisely, the Paterson conditions+would have us check that "the constraint has fewer constructors and variables+(taken together and counting repetitions) than the head.".++However, we can be a bit more refined by looking at which kind of constraint+this actually is. There are two main tricks:++ 1. It seems like it should be OK not to count the tuple type constructor+    for a PredType like (Show a, Eq a) :: Constraint, since we don't+    count the "implicit" tuple in the ThetaType itself.++    In fact, the Paterson test just checks *each component* of the top level+    ThetaType against the size bound, one at a time. By analogy, it should be+    OK to return the size of the *largest* tuple component as the size of the+    whole tuple.++ 2. Once we get into an implicit parameter or equality we+    can't get back to a class constraint, so it's safe+    to say "size 0".  See #4200.++NB: we don't want to detect PredTypes in sizeType (and then call+sizePred on them), or we might get an infinite loop if that PredType+is irreducible. See #5581.+-}++type TypeSize = IntWithInf++sizeType :: Type -> TypeSize+-- Size of a type: the number of variables and constructors+-- Ignore kinds altogether+sizeType = go+  where+    go ty | Just exp_ty <- tcView ty = go exp_ty+    go (TyVarTy {})              = 1+    go (TyConApp tc tys)+      | isTypeFamilyTyCon tc     = infinity  -- Type-family applications can+                                             -- expand to any arbitrary size+      | otherwise                = sizeTypes (filterOutInvisibleTypes tc tys) + 1+                                   -- Why filter out invisible args?  I suppose any+                                   -- size ordering is sound, but why is this better?+                                   -- I came across this when investigating #14010.+    go (LitTy {})                = 1+    go (FunTy _ arg res)         = go arg + go res + 1+    go (AppTy fun arg)           = go fun + go arg+    go (ForAllTy (Bndr tv vis) ty)+        | isVisibleArgFlag vis   = go (tyVarKind tv) + go ty + 1+        | otherwise              = go ty + 1+    go (CastTy ty _)             = go ty+    go (CoercionTy {})           = 0++sizeTypes :: [Type] -> TypeSize+sizeTypes tys = sum (map sizeType tys)++-----------------------------------------------------------------------------------+-----------------------------------------------------------------------------------+-----------------------+-- | For every arg a tycon can take, the returned list says True if the argument+-- is taken visibly, and False otherwise. Ends with an infinite tail of Trues to+-- allow for oversaturation.+tcTyConVisibilities :: TyCon -> [Bool]+tcTyConVisibilities tc = tc_binder_viss ++ tc_return_kind_viss ++ repeat True+  where+    tc_binder_viss      = map isVisibleTyConBinder (tyConBinders tc)+    tc_return_kind_viss = map isVisibleBinder (fst $ tcSplitPiTys (tyConResKind tc))++-- | If the tycon is applied to the types, is the next argument visible?+isNextTyConArgVisible :: TyCon -> [Type] -> Bool+isNextTyConArgVisible tc tys+  = tcTyConVisibilities tc `getNth` length tys++-- | Should this type be applied to a visible argument?+isNextArgVisible :: TcType -> Bool+isNextArgVisible ty+  | Just (bndr, _) <- tcSplitPiTy_maybe ty = isVisibleBinder bndr+  | otherwise                              = True+    -- this second case might happen if, say, we have an unzonked TauTv.+    -- But TauTvs can't range over types that take invisible arguments
+ compiler/GHC/Tc/Utils/TcType.hs-boot view
@@ -0,0 +1,8 @@+module GHC.Tc.Utils.TcType where+import GHC.Utils.Outputable( SDoc )++data MetaDetails++data TcTyVarDetails+pprTcTyVarDetails :: TcTyVarDetails -> SDoc+vanillaSkolemTv :: TcTyVarDetails
compiler/GHC/Types/Annotations.hs view
@@ -17,16 +17,14 @@         deserializeAnns     ) where -import GhcPrelude+import GHC.Prelude -import Binary-import GHC.Types.Module ( Module-                        , ModuleEnv, emptyModuleEnv, extendModuleEnvWith-                        , plusModuleEnv_C, lookupWithDefaultModuleEnv-                        , mapModuleEnv )+import GHC.Utils.Binary+import GHC.Unit.Module ( Module )+import GHC.Unit.Module.Env import GHC.Types.Name.Env import GHC.Types.Name-import Outputable+import GHC.Utils.Outputable import GHC.Serialized  import Control.Monad
compiler/GHC/Types/Avail.hs view
@@ -28,17 +28,17 @@    ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Name import GHC.Types.Name.Env import GHC.Types.Name.Set  import GHC.Types.FieldLabel-import Binary-import ListSetOps-import Outputable-import Util+import GHC.Utils.Binary+import GHC.Data.List.SetOps+import GHC.Utils.Outputable+import GHC.Utils.Misc  import Data.Data ( Data ) import Data.List ( find )
compiler/GHC/Types/Basic.hs view
@@ -67,7 +67,7 @@          OccInfo(..), noOccInfo, seqOccInfo, zapFragileOcc, isOneOcc,         isDeadOcc, isStrongLoopBreaker, isWeakLoopBreaker, isManyOccs,-        strongLoopBreaker, weakLoopBreaker,+        isNoOccInfo, strongLoopBreaker, weakLoopBreaker,          InsideLam(..),         OneBranch(..),@@ -113,10 +113,10 @@         TypeOrKind(..), isTypeLevel, isKindLevel    ) where -import GhcPrelude+import GHC.Prelude -import FastString-import Outputable+import GHC.Data.FastString+import GHC.Utils.Outputable import GHC.Types.SrcLoc ( Located,unLoc ) import Data.Data hiding (Fixity, Prefix, Infix) import Data.Function (on)@@ -619,7 +619,7 @@ --                              @'\{-\# INCOHERENT'@, --      'ApiAnnotation.AnnClose' @`\#-\}`@, --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data OverlapFlag = OverlapFlag   { overlapMode   :: OverlapMode   , isSafeOverlap :: Bool@@ -958,6 +958,10 @@ noOccInfo :: OccInfo noOccInfo = ManyOccs { occ_tail = NoTailCallInfo } +isNoOccInfo :: OccInfo -> Bool+isNoOccInfo ManyOccs { occ_tail = NoTailCallInfo } = True+isNoOccInfo _ = False+ isManyOccs :: OccInfo -> Bool isManyOccs ManyOccs{} = True isManyOccs _          = False@@ -1285,7 +1289,7 @@ data RuleMatchInfo = ConLike                    -- See Note [CONLIKE pragma]                    | FunLike                    deriving( Eq, Data, Show )-        -- Show needed for Lexer.x+        -- Show needed for GHC.Parser.Lexer  data InlinePragma            -- Note [InlinePragma]   = InlinePragma@@ -1313,7 +1317,7 @@   | NoUserInline -- User did not write any of INLINE/INLINABLE/NOINLINE                  -- e.g. in `defaultInlinePragma` or when created by CSE   deriving( Eq, Data, Show )-        -- Show needed for Lexer.x+        -- Show needed for GHC.Parser.Lexer  {- Note [InlinePragma] ~~~~~~~~~~~~~~~~~~~~~~@@ -1591,7 +1595,7 @@        , fl_value :: Rational      -- Numeric value of the literal        }   deriving (Data, Show)-  -- The Show instance is required for the derived Lexer.x:Token instance when DEBUG is on+  -- The Show instance is required for the derived GHC.Parser.Lexer.Token instance when DEBUG is on  mkFractionalLit :: Real a => a -> FractionalLit mkFractionalLit r = FL { fl_text = SourceText (show (realToFrac r::Double))
compiler/GHC/Types/CostCentre.hs view
@@ -20,17 +20,17 @@         cmpCostCentre   -- used for removing dups in a list     ) where -import GhcPrelude+import GHC.Prelude -import Binary+import GHC.Utils.Binary import GHC.Types.Var import GHC.Types.Name-import GHC.Types.Module+import GHC.Unit.Module import GHC.Types.Unique-import Outputable+import GHC.Utils.Outputable import GHC.Types.SrcLoc-import FastString-import Util+import GHC.Data.FastString+import GHC.Utils.Misc import GHC.Types.CostCentre.State  import Data.Data
compiler/GHC/Types/CostCentre/State.hs view
@@ -9,12 +9,12 @@    ) where -import GhcPrelude-import FastString-import FastStringEnv+import GHC.Prelude+import GHC.Data.FastString+import GHC.Data.FastString.Env  import Data.Data-import Binary+import GHC.Utils.Binary  -- | Per-module state for tracking cost centre indices. --
compiler/GHC/Types/Cpr.hs view
@@ -1,5 +1,5 @@ {-# LANGUAGE GeneralisedNewtypeDeriving #-}--- | Types for the Constructed Product Result lattice. "GHC.Core.Op.CprAnal" and "GHC.Core.Op.WorkWrap.Lib"+-- | Types for the Constructed Product Result lattice. "GHC.Core.Opt.CprAnal" and "GHC.Core.Opt.WorkWrap.Utils" -- are its primary customers via 'idCprInfo'. module GHC.Types.Cpr (     CprResult, topCpr, botCpr, conCpr, asConCpr,@@ -8,11 +8,11 @@     CprSig (..), topCprSig, mkCprSigForArity, mkCprSig, seqCprSig   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Basic-import Outputable-import Binary+import GHC.Utils.Outputable+import GHC.Utils.Binary  -- -- * CprResult
compiler/GHC/Types/Demand.hs view
@@ -58,16 +58,16 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable import GHC.Types.Var ( Var ) import GHC.Types.Var.Env import GHC.Types.Unique.FM-import Util+import GHC.Utils.Misc import GHC.Types.Basic-import Binary-import Maybes           ( orElse )+import GHC.Utils.Binary+import GHC.Data.Maybe   ( orElse )  import GHC.Core.Type    ( Type ) import GHC.Core.TyCon   ( isNewTyCon, isClassTyCon )@@ -680,7 +680,7 @@ mkCallDmds :: Arity -> CleanDemand -> CleanDemand mkCallDmds arity cd = iterate mkCallDmd cd !! arity --- See Note [Demand on the worker] in GHC.Core.Op.WorkWrap+-- See Note [Demand on the worker] in GHC.Core.Opt.WorkWrap mkWorkerDemand :: Int -> Demand mkWorkerDemand n = JD { sd = Lazy, ud = Use One (go n) }   where go 0 = Used@@ -858,7 +858,7 @@ deeply-nested than its type.  There are various ways to tackle this. When processing (x |> g1), we could "trim" the incoming demand U(U,U) to match x's type.  But I'm currently doing so just at the moment when-we pin a demand on a binder, in GHC.Core.Op.DmdAnal.findBndrDmd.+we pin a demand on a binder, in GHC.Core.Opt.DmdAnal.findBndrDmd.   Note [Threshold demands]@@ -931,6 +931,54 @@   ppr Diverges      = char 'b'   ppr Dunno         = empty +{- Note [Precise vs imprecise exceptions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+An exception is considered to be /precise/ when it is thrown by the 'raiseIO#'+primop. It follows that all other primops (such as 'raise#' or+division-by-zero) throw /imprecise/ exceptions. Note that the actual type of+the exception thrown doesn't have any impact!++GHC undertakes some effort not to apply an optimisation that would mask a+/precise/ exception with some other source of nontermination, such as genuine+divergence or an imprecise exception, so that the user can reliably+intercept the precise exception with a catch handler before and after+optimisations.++See also the wiki page on precise exceptions:+https://gitlab.haskell.org/ghc/ghc/wikis/exceptions/precise-exceptions+Section 5 of "Tackling the awkward squad" talks about semantic concerns.+Imprecise exceptions are actually more interesting than precise ones (which are+fairly standard) from the perspective of semantics. See the paper "A Semantics+for Imprecise Exceptions" for more details.++Note [Precise exceptions and strictness analysis]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+raiseIO# raises a *precise* exception, in contrast to raise# which+raise an *imprecise* exception.  See Note [Precise vs imprecise exceptions]+in XXXX.++Unlike raise# (which returns botDiv), we want raiseIO# to return topDiv.+Here's why. Consider this example from #13380 (similarly #17676):+    f x y | x>0       = raiseIO Exc+          | y>0       = return 1+          | otherwise = return 2+Is 'f' strict in 'y'? One might be tempted to say yes! But that plays fast and+loose with the precise exception; after optimisation, (f 42 (error "boom"))+turns from throwing the precise Exc to throwing the imprecise user error+"boom". So, the defaultDmd of raiseIO# should be lazy (topDmd), which can be+achieved by giving it divergence topDiv.++But if it returns topDiv, the simplifier will fail to discard raiseIO#'s+continuation in+   case raiseIO# x s of { (# s', r #) -> <BIG> }+which we'd like to optimise to+   raiseIO# x s+Temporary hack solution: special treatment for raiseIO# in+Simplifier.Utils.mkArgInfo. For the non-hack solution, see+https://gitlab.haskell.org/ghc/ghc/wikis/fixing-precise-exceptions#replacing-hacks-by-principled-program-analyses+-}++ ------------------------------------------------------------------------ -- Combined demand result                                             -- ------------------------------------------------------------------------@@ -1052,7 +1100,7 @@ 3 and 4 are implemented in bothDivergence. -} --- Equality needed for fixpoints in GHC.Core.Op.DmdAnal+-- Equality needed for fixpoints in GHC.Core.Opt.DmdAnal instance Eq DmdType where   (==) (DmdType fv1 ds1 div1)        (DmdType fv2 ds2 div2) = nonDetUFMToList fv1 == nonDetUFMToList fv2@@ -1173,7 +1221,7 @@ -- * We can keep usage information (i.e. lub with an absent demand) -- * We have to kill definite divergence -- * We can keep CPR information.--- See Note [IO hack in the demand analyser] in GHC.Core.Op.DmdAnal+-- See Note [IO hack in the demand analyser] in GHC.Core.Opt.DmdAnal deferAfterIO :: DmdType -> DmdType deferAfterIO d@(DmdType _ _ res) =     case d `lubDmdType` nopDmdType of@@ -1529,7 +1577,7 @@ type's depth! So in mkStrictSigForArity we make sure to trim the list of argument demands to the given threshold arity. Call sites will make sure that this corresponds to the arity of the call demand that elicited the wrapped-demand type. See also Note [What are demand signatures?] in GHC.Core.Op.DmdAnal.+demand type. See also Note [What are demand signatures?] in GHC.Core.Opt.DmdAnal.  Besides trimming argument demands, mkStrictSigForArity will also trim CPR information if necessary.@@ -1618,17 +1666,15 @@   = postProcessUnsat (peelManyCalls (length arg_ds) cd) dmd_ty     -- see Note [Demands from unsaturated function calls] -dmdTransformDataConSig :: Arity -> StrictSig -> CleanDemand -> DmdType+dmdTransformDataConSig :: Arity -> CleanDemand -> DmdType -- Same as dmdTransformSig but for a data constructor (worker), -- which has a special kind of demand transformer. -- If the constructor is saturated, we feed the demand on -- the result into the constructor arguments.-dmdTransformDataConSig arity (StrictSig (DmdType _ _ con_res))-                             (JD { sd = str, ud = abs })+dmdTransformDataConSig arity (JD { sd = str, ud = abs })   | Just str_dmds <- go_str arity str   , Just abs_dmds <- go_abs arity abs-  = DmdType emptyDmdEnv (mkJointDmds str_dmds abs_dmds) con_res-                -- Must remember whether it's a product, hence con_res, not TopRes+  = DmdType emptyDmdEnv (mkJointDmds str_dmds abs_dmds) topDiv    | otherwise   -- Not saturated   = nopDmdType@@ -1702,7 +1748,7 @@ -- saturatedByOneShots n C1(C1(...)) = True, --   <=> -- there are at least n nested C1(..) calls--- See Note [Demand on the worker] in GHC.Core.Op.WorkWrap+-- See Note [Demand on the worker] in GHC.Core.Opt.WorkWrap saturatedByOneShots :: Int -> Demand -> Bool saturatedByOneShots n (JD { ud = usg })   = case usg of
compiler/GHC/Types/FieldLabel.hs view
@@ -71,15 +71,15 @@    ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Name.Occurrence import GHC.Types.Name -import FastString-import FastStringEnv-import Outputable-import Binary+import GHC.Data.FastString+import GHC.Data.FastString.Env+import GHC.Utils.Outputable+import GHC.Utils.Binary  import Data.Data
compiler/GHC/Types/ForeignCall.hs view
@@ -18,12 +18,12 @@         Header(..), CType(..),     ) where -import GhcPrelude+import GHC.Prelude -import FastString-import Binary-import Outputable-import GHC.Types.Module+import GHC.Data.FastString+import GHC.Utils.Binary+import GHC.Utils.Outputable+import GHC.Unit.Module import GHC.Types.Basic ( SourceText, pprWithSourceText )  import Data.Char@@ -112,7 +112,7 @@                                   -- See note [Pragma source text] in GHC.Types.Basic         CLabelString                    -- C-land name of label. -        (Maybe UnitId)              -- What package the function is in.+        (Maybe Unit)                    -- What package the function is in.                                         -- If Nothing, then it's taken to be in the current package.                                         -- Note: This information is only used for PrimCalls on Windows.                                         --       See CLabel.labelDynamic and CoreToStg.coreToStgApp@@ -231,7 +231,7 @@ --        'ApiAnnotation.AnnHeader','ApiAnnotation.AnnVal', --        'ApiAnnotation.AnnClose' @'\#-}'@, --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data CType = CType SourceText -- Note [Pragma source text] in GHC.Types.Basic                    (Maybe Header) -- header to include for this type                    (SourceText,FastString) -- the type itself
compiler/GHC/Types/Id.hs view
@@ -118,7 +118,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Driver.Session import GHC.Core ( CoreRule, isStableUnfolding, evaldUnfolding,@@ -137,22 +137,22 @@  import GHC.Core.Type import GHC.Types.RepType-import TysPrim+import GHC.Builtin.Types.Prim import GHC.Core.DataCon import GHC.Types.Demand import GHC.Types.Cpr import GHC.Types.Name-import GHC.Types.Module+import GHC.Unit.Module import GHC.Core.Class-import {-# SOURCE #-} PrimOp (PrimOp)+import {-# SOURCE #-} GHC.Builtin.PrimOps (PrimOp) import GHC.Types.ForeignCall-import Maybes+import GHC.Data.Maybe import GHC.Types.SrcLoc-import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique import GHC.Types.Unique.Supply-import FastString-import Util+import GHC.Data.FastString+import GHC.Utils.Misc  -- infixl so you can say (id `set` a `set` b) infixl  1 `setIdUnfolding`,@@ -488,7 +488,7 @@                          _                 -> Nothing  isJoinId :: Var -> Bool--- It is convenient in GHC.Core.Op.SetLevels.lvlMFE to apply isJoinId+-- It is convenient in GHC.Core.Opt.SetLevels.lvlMFE to apply isJoinId -- to the free vars of an expression, so it's convenient -- if it returns False for type variables isJoinId id@@ -519,7 +519,7 @@ -- they aren't any more.  Instead, we inject a binding for -- them at the CorePrep stage. ----- 'PrimOpId's also used to be of this kind. See Note [Primop wrappers] in PrimOp.hs.+-- 'PrimOpId's also used to be of this kind. See Note [Primop wrappers] in GHC.Builtin.PrimOps. -- for the history of this. -- -- Note that CorePrep currently eta expands things no-binding things and this@@ -528,7 +528,7 @@ -- -- EXCEPT: unboxed tuples, which definitely have no binding hasNoBinding id = case Var.idDetails id of-                        PrimOpId _       -> False   -- See Note [Primop wrappers] in PrimOp.hs+                        PrimOpId _       -> False   -- See Note [Primop wrappers] in GHC.Builtin.PrimOps                         FCallId _        -> True                         DataConWorkId dc -> isUnboxedTupleCon dc || isUnboxedSumCon dc                         _                -> isCompulsoryUnfolding (idUnfolding id)@@ -768,7 +768,7 @@ idRuleMatchInfo id = inlinePragmaRuleMatchInfo (idInlinePragma id)  isConLikeId :: Id -> Bool-isConLikeId id = isDataConWorkId id || isConLike (idRuleMatchInfo id)+isConLikeId id = isConLike (idRuleMatchInfo id)  {-         ---------------------------------@@ -894,7 +894,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~ This transfer is used in three places:         FloatOut (long-distance let-floating)-        GHC.Core.Op.Simplify.Utils.abstractFloats (short-distance let-floating)+        GHC.Core.Opt.Simplify.Utils.abstractFloats (short-distance let-floating)         StgLiftLams (selectively lambda-lift local functions to top-level)  Consider the short-distance let-floating:
compiler/GHC/Types/Id/Info.hs view
@@ -84,12 +84,13 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import GHC.Core+import GHC.Core hiding( hasCoreUnfolding )+import GHC.Core( hasCoreUnfolding )  import GHC.Core.Class-import {-# SOURCE #-} PrimOp (PrimOp)+import {-# SOURCE #-} GHC.Builtin.PrimOps (PrimOp) import GHC.Types.Name import GHC.Types.Var.Set import GHC.Types.Basic@@ -98,11 +99,11 @@ import GHC.Core.PatSyn import GHC.Core.Type import GHC.Types.ForeignCall-import Outputable-import GHC.Types.Module+import GHC.Utils.Outputable+import GHC.Unit.Module import GHC.Types.Demand import GHC.Types.Cpr-import Util+import GHC.Utils.Misc  -- infixl so you can say (id `set` a `set` b) infixl  1 `setRuleInfo`,@@ -138,7 +139,7 @@     { sel_tycon   :: RecSelParent     , sel_naughty :: Bool       -- True <=> a "naughty" selector which can't actually exist, for example @x@ in:                                 --    data T = forall a. MkT { x :: a }-    }                           -- See Note [Naughty record selectors] in TcTyClsDecls+    }                           -- See Note [Naughty record selectors] in GHC.Tc.TyCl    | DataConWorkId DataCon       -- ^ The 'Id' is for a data constructor /worker/   | DataConWrapId DataCon       -- ^ The 'Id' is for a data constructor /wrapper/@@ -567,8 +568,8 @@  zapFragileUnfolding :: Unfolding -> Unfolding zapFragileUnfolding unf- | isFragileUnfolding unf = noUnfolding- | otherwise              = unf+ | hasCoreUnfolding unf = noUnfolding+ | otherwise            = unf  zapUnfolding :: Unfolding -> Unfolding -- Squash all unfolding info, preserving only evaluated-ness
compiler/GHC/Types/Id/Info.hs-boot view
@@ -1,6 +1,6 @@ module GHC.Types.Id.Info where-import GhcPrelude-import Outputable+import GHC.Prelude+import GHC.Utils.Outputable data IdInfo data IdDetails
compiler/GHC/Types/Id/Make.hs view
@@ -35,31 +35,31 @@         coerceName,          -- Re-export error Ids-        module GHC.Core.Op.ConstantFold+        module GHC.Core.Opt.ConstantFold     ) where  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import GHC.Core.Rules-import TysPrim-import TysWiredIn-import GHC.Core.Op.ConstantFold+import GHC.Builtin.Types.Prim+import GHC.Builtin.Types+import GHC.Core.Opt.ConstantFold import GHC.Core.Type import GHC.Core.TyCo.Rep import GHC.Core.FamInstEnv import GHC.Core.Coercion-import TcType+import GHC.Tc.Utils.TcType as TcType import GHC.Core.Make-import GHC.Core.Utils  ( mkCast, mkDefaultCase )+import GHC.Core.FVs     ( mkRuleInfo )+import GHC.Core.Utils   ( mkCast, mkDefaultCase ) import GHC.Core.Unfold import GHC.Types.Literal import GHC.Core.TyCon import GHC.Core.Class import GHC.Types.Name.Set import GHC.Types.Name-import PrimOp+import GHC.Builtin.PrimOps import GHC.Types.ForeignCall import GHC.Core.DataCon import GHC.Types.Id@@ -69,13 +69,13 @@ import GHC.Core import GHC.Types.Unique import GHC.Types.Unique.Supply-import PrelNames+import GHC.Builtin.Names import GHC.Types.Basic       hiding ( SuccessFlag(..) )-import Util+import GHC.Utils.Misc import GHC.Driver.Session-import Outputable-import FastString-import ListSetOps+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Data.List.SetOps import GHC.Types.Var (VarBndr(Bndr)) import qualified GHC.LanguageExtensions as LangExt @@ -420,14 +420,14 @@          = base_info `setInlinePragInfo` alwaysInlinePragma                      `setUnfoldingInfo`  mkInlineUnfoldingWithArity 1                                            (mkDictSelRhs clas val_index)-                   -- See Note [Single-method classes] in TcInstDcls+                   -- See Note [Single-method classes] in GHC.Tc.TyCl.Instance                    -- for why alwaysInlinePragma           | otherwise          = base_info `setRuleInfo` mkRuleInfo [rule]                    -- Add a magic BuiltinRule, but no unfolding                    -- so that the rule is always available to fire.-                   -- See Note [ClassOp/DFun selection] in TcInstDcls+                   -- See Note [ClassOp/DFun selection] in GHC.Tc.TyCl.Instance      -- This is the built-in rule that goes     --      op (dfT d1 d2) --->  opT d1 d2@@ -506,44 +506,25 @@     tycon  = dataConTyCon data_con  -- The representation TyCon     wkr_ty = dataConRepType data_con -        ----------- Workers for data types --------------+    ----------- Workers for data types --------------     alg_wkr_info = noCafIdInfo                    `setArityInfo`          wkr_arity-                   `setStrictnessInfo`     wkr_sig                    `setCprInfo`            mkCprSig wkr_arity (dataConCPR data_con)+                   `setInlinePragInfo`     wkr_inline_prag                    `setUnfoldingInfo`      evaldUnfolding  -- Record that it's evaluated,                                                            -- even if arity = 0                    `setLevityInfoWithType` wkr_ty                      -- NB: unboxed tuples have workers, so we can't use                      -- setNeverLevPoly +    wkr_inline_prag = defaultInlinePragma { inl_rule = ConLike }     wkr_arity = dataConRepArity 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-        --      e.g.    data T = MkT !(Int,Int)-        -- Why?  Because the *wrapper* $WMkT is strict (and its unfolding has-        -- case expressions that do the evals) but the *worker* MkT itself is-        --  not. If we pretend it is strict then when we see-        --      case x of y -> MkT y-        -- the simplifier thinks that y is "sure to be evaluated" (because-        -- the worker MkT is strict) and drops the case.  No, the workerId-        -- MkT is not strict.-        ---        -- However, the worker does have StrictnessMarks.  When the simplifier-        -- sees a pattern-        --      case e of MkT x -> ...-        -- it uses the dataConRepStrictness of MkT to mark x as evaluated;-        -- but that's fine... dataConRepStrictness comes from the data con-        -- not from the worker Id.--        ----------- Workers for newtypes --------------+    ----------- Workers for newtypes --------------     univ_tvs = dataConUnivTyVars data_con     arg_tys  = dataConRepArgTys  data_con  -- Should be same as dataConOrigArgTys     nt_work_info = noCafIdInfo          -- The NoCaf-ness is set by noCafIdInfo                   `setArityInfo` 1      -- Arity 1-                  `setInlinePragInfo`     alwaysInlinePragma+                  `setInlinePragInfo`     dataConWrapperInlinePragma                   `setUnfoldingInfo`      newtype_unf                   `setLevityInfoWithType` wkr_ty     id_arg1      = mkTemplateLocal 1 (head arg_tys)@@ -673,8 +654,8 @@              mk_dmd str | isBanged str = evalDmd                         | otherwise    = topDmd -             wrap_prag = alwaysInlinePragma `setInlinePragmaActivation`-                         activeDuringFinal+             wrap_prag = dataConWrapperInlinePragma+                         `setInlinePragmaActivation` activeDuringFinal                          -- See Note [Activation for data constructor wrappers]               -- The wrapper will usually be inlined (see wrap_unf), so its@@ -784,6 +765,12 @@            ; expr <- mk_rep_app prs (mkVarApps con_app rep_ids)            ; return (unbox_fn expr) } ++dataConWrapperInlinePragma :: InlinePragma+-- See Note [DataCon wrappers are conlike]+dataConWrapperInlinePragma = alwaysInlinePragma { inl_rule = ConLike+                                                , inl_inline = Inline }+ {- Note [Activation for data constructor wrappers] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The Activation on a data constructor wrapper allows it to inline only in Phase@@ -805,7 +792,38 @@  See also https://gitlab.haskell.org/ghc/ghc/issues/15840 . +Note [DataCon wrappers are conlike]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+DataCon workers are clearly ConLike --- they are the “Con” in+“ConLike”, after all --- but what about DataCon wrappers? Should they+be marked ConLike, too? +Yes, absolutely! As described in Note [CONLIKE pragma] in+GHC.Types.Basic, isConLike influences GHC.Core.Utils.exprIsExpandable,+which is used by both RULE matching and the case-of-known-constructor+optimization. It’s crucial that both of those things can see+applications of DataCon wrappers:++  * User-defined RULEs match on wrappers, not workers, so we might+    need to look through an unfolding built from a DataCon wrapper to+    determine if a RULE matches.++  * Likewise, if we have something like+        let x = $WC a b in ... case x of { C y z -> e } ...+    we still want to apply case-of-known-constructor.++Therefore, it’s important that we consider DataCon wrappers conlike.+This is especially true now that we don’t inline DataCon wrappers+until the final simplifier phase; see Note [Activation for data+constructor wrappers].++For further reading, see:+  * Note [Conlike is interesting] in GHC.Core.Op.Simplify.Utils+  * Note [Lone variables] in GHC.Core.Unfold+  * Note [exprIsConApp_maybe on data constructors with wrappers]+    in GHC.Core.SimpleOpt+  * #18012+ Note [Bangs on imported data constructors] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -1187,7 +1205,7 @@ -- When unwrapping, we do *not* apply any family coercion, because this will -- be done via a CoPat by the type checker.  We have to do it this way as -- computing the right type arguments for the coercion requires more than just--- a splitting operation (cf, TcPat.tcConPat).+-- a splitting operation (cf, GHC.Tc.Gen.Pat.tcConPat).  unwrapNewTypeBody :: TyCon -> [Type] -> CoreExpr -> CoreExpr unwrapNewTypeBody tycon args result_expr@@ -1298,7 +1316,7 @@             -> Class             -> [Type]             -> Id--- Implements the DFun Superclass Invariant (see TcInstDcls)+-- Implements the DFun Superclass Invariant (see GHC.Tc.TyCl.Instance) -- See Note [Dict funs and default methods]  mkDictFunId dfun_name tvs theta clas tys@@ -1477,7 +1495,7 @@ c) There is some special rule handing: Note [User-defined RULES for seq]  Historical note:-    In TcExpr we used to need a special typing rule for 'seq', to handle calls+    In GHC.Tc.Gen.Expr we used to need a special typing rule for 'seq', to handle calls     whose second argument had an unboxed type, e.g.  x `seq` 3#      However, with levity polymorphism we can now give seq the type seq ::@@ -1500,7 +1518,7 @@  You write that rule.  When GHC sees a case expression that discards its result, it mentally transforms it to a call to 'seq' and looks for-a RULE.  (This is done in GHC.Core.Op.Simplify.trySeqRules.)  As usual, the+a RULE.  (This is done in GHC.Core.Opt.Simplify.trySeqRules.)  As usual, the correctness of the rule is up to you.  VERY IMPORTANT: to make this work, we give the RULE an arity of 1, not 2.@@ -1512,10 +1530,10 @@     for saturated application of 'seq' would turn the LHS into     a case expression! -  - The code in GHC.Core.Op.Simplify.rebuildCase would need to actually supply+  - The code in GHC.Core.Opt.Simplify.rebuildCase would need to actually supply     the value argument, which turns out to be awkward. -See also: Note [User-defined RULES for seq] in GHC.Core.Op.Simplify.+See also: Note [User-defined RULES for seq] in GHC.Core.Opt.Simplify.   Note [lazyId magic]@@ -1611,7 +1629,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 GHC.Core.Op.Tidy.+OneShotInfo] in GHC.Core.Tidy.  Also see https://gitlab.haskell.org/ghc/ghc/wikis/one-shot. @@ -1647,7 +1665,7 @@ a `Proxy` parameter which is used to link the type of the constraint, `C a`, with the type of the `Wrap` value being made. -Next, we add a built-in Prelude rule (see GHC.Core.Op.ConstantFold),+Next, we add a built-in Prelude rule (see GHC.Core.Opt.ConstantFold), which will replace the RHS of this definition with the appropriate definition in Core.  The rewrite rule works as follows:
compiler/GHC/Types/Id/Make.hs-boot view
@@ -3,7 +3,7 @@ import GHC.Types.Var( Id ) import GHC.Core.Class( Class ) import {-# SOURCE #-} GHC.Core.DataCon( DataCon )-import {-# SOURCE #-} PrimOp( PrimOp )+import {-# SOURCE #-} GHC.Builtin.PrimOps( PrimOp )  data DataConBoxer
compiler/GHC/Types/Literal.hs view
@@ -50,20 +50,20 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import TysPrim-import PrelNames+import GHC.Builtin.Types.Prim+import GHC.Builtin.Names import GHC.Core.Type import GHC.Core.TyCon-import Outputable-import FastString+import GHC.Utils.Outputable+import GHC.Data.FastString import GHC.Types.Basic-import Binary-import Constants+import GHC.Utils.Binary+import GHC.Settings.Constants import GHC.Platform import GHC.Types.Unique.FM-import Util+import GHC.Utils.Misc  import Data.ByteString (ByteString) import Data.Int@@ -675,7 +675,7 @@ absentLiteralOf :: TyCon -> Maybe Literal -- Return a literal of the appropriate primitive -- TyCon, to use as a placeholder when it doesn't matter--- Rubbish literals are handled in GHC.Core.Op.WorkWrap.Lib, because+-- Rubbish literals are handled in GHC.Core.Opt.WorkWrap.Utils, because --  1. Looking at the TyCon is not enough, we need the actual type --  2. This would need to return a type application to a literal absentLiteralOf tc = lookupUFM absent_lits (tyConName tc)@@ -830,7 +830,7 @@  * It is given its polymorphic type by Literal.literalType -* GHC.Core.Op.WorkWrap.Lib.mk_absent_let introduces a LitRubbish for absent+* GHC.Core.Opt.WorkWrap.Utils.mk_absent_let introduces a LitRubbish for absent   arguments of boxed, unlifted type.  * In CoreToSTG we convert (RubishLit @t) to just ().  STG is
− compiler/GHC/Types/Module.hs 
@@ -1,1322 +0,0 @@-{--(c) The University of Glasgow, 2004-2006---Module-~~~~~~~~~~-Simply the name of a module, represented as a FastString.-These are Uniquable, hence we can build Maps with Modules as-the keys.--}--{-# LANGUAGE RecordWildCards #-}-{-# LANGUAGE MultiParamTypeClasses #-}--module GHC.Types.Module-    (-        -- * The ModuleName type-        ModuleName,-        pprModuleName,-        moduleNameFS,-        moduleNameString,-        moduleNameSlashes, moduleNameColons,-        moduleStableString,-        moduleFreeHoles,-        moduleIsDefinite,-        mkModuleName,-        mkModuleNameFS,-        stableModuleNameCmp,--        -- * The UnitId type-        ComponentId(..),-        ComponentDetails(..),-        UnitId(..),-        unitIdFS,-        unitIdKey,-        IndefUnitId(..),-        IndefModule(..),-        indefUnitIdToUnitId,-        indefModuleToModule,-        InstalledUnitId(..),-        toInstalledUnitId,-        ShHoleSubst,--        unitIdIsDefinite,-        unitIdString,-        unitIdFreeHoles,--        newUnitId,-        newIndefUnitId,-        newSimpleUnitId,-        hashUnitId,-        fsToUnitId,-        stringToUnitId,-        stableUnitIdCmp,--        -- * HOLE renaming-        renameHoleUnitId,-        renameHoleModule,-        renameHoleUnitId',-        renameHoleModule',--        -- * Generalization-        splitModuleInsts,-        splitUnitIdInsts,-        generalizeIndefUnitId,-        generalizeIndefModule,--        -- * Parsers-        parseModuleName,-        parseUnitId,-        parseComponentId,-        parseModuleId,-        parseModSubst,--        -- * Wired-in UnitIds-        -- $wired_in_packages-        primUnitId,-        integerUnitId,-        baseUnitId,-        rtsUnitId,-        thUnitId,-        mainUnitId,-        thisGhcUnitId,-        isHoleModule,-        interactiveUnitId, isInteractiveModule,-        wiredInUnitIds,--        -- * The Module type-        Module(Module),-        moduleUnitId, moduleName,-        pprModule,-        mkModule,-        mkHoleModule,-        stableModuleCmp,-        HasModule(..),-        ContainsModule(..),--        -- * Installed unit ids and modules-        InstalledModule(..),-        InstalledModuleEnv,-        installedModuleEq,-        installedUnitIdEq,-        installedUnitIdString,-        fsToInstalledUnitId,-        componentIdToInstalledUnitId,-        stringToInstalledUnitId,-        emptyInstalledModuleEnv,-        lookupInstalledModuleEnv,-        extendInstalledModuleEnv,-        filterInstalledModuleEnv,-        delInstalledModuleEnv,-        DefUnitId(..),--        -- * The ModuleLocation type-        ModLocation(..),-        addBootSuffix, addBootSuffix_maybe,-        addBootSuffixLocn, addBootSuffixLocnOut,--        -- * Module mappings-        ModuleEnv,-        elemModuleEnv, extendModuleEnv, extendModuleEnvList,-        extendModuleEnvList_C, plusModuleEnv_C,-        delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv,-        lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv,-        moduleEnvKeys, moduleEnvElts, moduleEnvToList,-        unitModuleEnv, isEmptyModuleEnv,-        extendModuleEnvWith, filterModuleEnv,--        -- * ModuleName mappings-        ModuleNameEnv, DModuleNameEnv,--        -- * Sets of Modules-        ModuleSet,-        emptyModuleSet, mkModuleSet, moduleSetElts,-        extendModuleSet, extendModuleSetList, delModuleSet,-        elemModuleSet, intersectModuleSet, minusModuleSet, unionModuleSet,-        unitModuleSet-    ) where--import GhcPrelude--import Outputable-import GHC.Types.Unique-import GHC.Types.Unique.FM-import GHC.Types.Unique.DFM-import GHC.Types.Unique.DSet-import FastString-import Binary-import Util-import Data.List (sortBy, sort)-import Data.Ord-import Data.Version-import GHC.PackageDb-import Fingerprint--import qualified Data.ByteString as BS-import qualified Data.ByteString.Char8 as BS.Char8-import Encoding--import qualified Text.ParserCombinators.ReadP as Parse-import Text.ParserCombinators.ReadP (ReadP, (<++))-import Data.Char (isAlphaNum)-import Control.DeepSeq-import Data.Coerce-import Data.Data-import Data.Function-import Data.Map (Map)-import Data.Set (Set)-import qualified Data.Map as Map-import qualified Data.Set as Set-import qualified FiniteMap as Map-import System.FilePath--import {-# SOURCE #-} GHC.Driver.Session (DynFlags)-import {-# SOURCE #-} GHC.Driver.Packages (improveUnitId, componentIdString, UnitInfoMap, getUnitInfoMap, displayInstalledUnitId, getPackageState)---- Note [The identifier lexicon]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- Unit IDs, installed package IDs, ABI hashes, package names,--- versions, there are a *lot* of different identifiers for closely--- related things.  What do they all mean? Here's what.  (See also--- https://gitlab.haskell.org/ghc/ghc/wikis/commentary/packages/concepts )------ THE IMPORTANT ONES------ ComponentId: An opaque identifier provided by Cabal, which should--- uniquely identify such things as the package name, the package--- version, the name of the component, the hash of the source code--- tarball, the selected Cabal flags, GHC flags, direct dependencies of--- the component.  These are very similar to InstalledPackageId, but--- an 'InstalledPackageId' implies that it identifies a package, while--- a package may install multiple components with different--- 'ComponentId's.---      - Same as Distribution.Package.ComponentId------ UnitId/InstalledUnitId: A ComponentId + a mapping from hole names--- (ModuleName) to Modules.  This is how the compiler identifies instantiated--- components, and also is the main identifier by which GHC identifies things.---      - When Backpack is not being used, UnitId = ComponentId.---        this means a useful fiction for end-users is that there are---        only ever ComponentIds, and some ComponentIds happen to have---        more information (UnitIds).---      - Same as Language.Haskell.TH.Syntax:PkgName, see---          https://gitlab.haskell.org/ghc/ghc/issues/10279---      - The same as PackageKey in GHC 7.10 (we renamed it because---        they don't necessarily identify packages anymore.)---      - Same as -this-package-key/-package-name flags---      - An InstalledUnitId corresponds to an actual package which---        we have installed on disk.  It could be definite or indefinite,---        but if it's indefinite, it has nothing instantiated (we---        never install partially instantiated units.)------ Module/InstalledModule: A UnitId/InstalledUnitId + ModuleName. This is how--- the compiler identifies modules (e.g. a Name is a Module + OccName)---      - Same as Language.Haskell.TH.Syntax:Module------ THE LESS IMPORTANT ONES------ PackageName: The "name" field in a Cabal file, something like "lens".---      - Same as Distribution.Package.PackageName---      - DIFFERENT FROM Language.Haskell.TH.Syntax:PkgName, see---          https://gitlab.haskell.org/ghc/ghc/issues/10279---      - DIFFERENT FROM -package-name flag---      - DIFFERENT FROM the 'name' field in an installed package---        information.  This field could more accurately be described---        as a munged package name: when it's for the main library---        it is the same as the package name, but if it's an internal---        library it's a munged combination of the package name and---        the component name.------ LEGACY ONES------ InstalledPackageId: This is what we used to call ComponentId.--- It's a still pretty useful concept for packages that have only--- one library; in that case the logical InstalledPackageId =--- ComponentId.  Also, the Cabal nix-local-build continues to--- compute an InstalledPackageId which is then forcibly used--- for all components in a package.  This means that if a dependency--- from one component in a package changes, the InstalledPackageId--- changes: you don't get as fine-grained dependency tracking,--- but it means your builds are hermetic.  Eventually, Cabal will--- deal completely in components and we can get rid of this.------ PackageKey: This is what we used to call UnitId.  We ditched--- "Package" from the name when we realized that you might want to--- assign different "PackageKeys" to components from the same package.--- (For a brief, non-released period of time, we also called these--- UnitKeys).--{--************************************************************************-*                                                                      *-\subsection{Module locations}-*                                                                      *-************************************************************************--}---- | Module Location------ Where a module lives on the file system: the actual locations--- of the .hs, .hi and .o files, if we have them-data ModLocation-   = ModLocation {-        ml_hs_file   :: Maybe FilePath,-                -- The source file, if we have one.  Package modules-                -- probably don't have source files.--        ml_hi_file   :: FilePath,-                -- Where the .hi file is, whether or not it exists-                -- yet.  Always of form foo.hi, even if there is an-                -- hi-boot file (we add the -boot suffix later)--        ml_obj_file  :: FilePath,-                -- Where the .o file is, whether or not it exists yet.-                -- (might not exist either because the module hasn't-                -- been compiled yet, or because it is part of a-                -- package with a .a file)-        ml_hie_file  :: FilePath-  } deriving Show--instance Outputable ModLocation where-   ppr = text . show--{--For a module in another package, the hs_file and obj_file-components of ModLocation are undefined.--The locations specified by a ModLocation may or may not-correspond to actual files yet: for example, even if the object-file doesn't exist, the ModLocation still contains the path to-where the object file will reside if/when it is created.--}--addBootSuffix :: FilePath -> FilePath--- ^ Add the @-boot@ suffix to .hs, .hi and .o files-addBootSuffix path = path ++ "-boot"--addBootSuffix_maybe :: Bool -> FilePath -> FilePath--- ^ Add the @-boot@ suffix if the @Bool@ argument is @True@-addBootSuffix_maybe is_boot path- | is_boot   = addBootSuffix path- | otherwise = path--addBootSuffixLocn :: ModLocation -> ModLocation--- ^ Add the @-boot@ suffix to all file paths associated with the module-addBootSuffixLocn locn-  = locn { ml_hs_file  = fmap addBootSuffix (ml_hs_file locn)-         , ml_hi_file  = addBootSuffix (ml_hi_file locn)-         , ml_obj_file = addBootSuffix (ml_obj_file locn)-         , ml_hie_file = addBootSuffix (ml_hie_file locn) }--addBootSuffixLocnOut :: ModLocation -> ModLocation--- ^ Add the @-boot@ suffix to all output file paths associated with the--- module, not including the input file itself-addBootSuffixLocnOut locn-  = locn { ml_hi_file  = addBootSuffix (ml_hi_file locn)-         , ml_obj_file = addBootSuffix (ml_obj_file locn)-         , ml_hie_file = addBootSuffix (ml_hie_file locn) }--{--************************************************************************-*                                                                      *-\subsection{The name of a module}-*                                                                      *-************************************************************************--}---- | A ModuleName is essentially a simple string, e.g. @Data.List@.-newtype ModuleName = ModuleName FastString--instance Uniquable ModuleName where-  getUnique (ModuleName nm) = getUnique nm--instance Eq ModuleName where-  nm1 == nm2 = getUnique nm1 == getUnique nm2--instance Ord ModuleName where-  nm1 `compare` nm2 = stableModuleNameCmp nm1 nm2--instance Outputable ModuleName where-  ppr = pprModuleName--instance Binary ModuleName where-  put_ bh (ModuleName fs) = put_ bh fs-  get bh = do fs <- get bh; return (ModuleName fs)--instance BinaryStringRep ModuleName where-  fromStringRep = mkModuleNameFS . mkFastStringByteString-  toStringRep   = bytesFS . moduleNameFS--instance Data ModuleName where-  -- don't traverse?-  toConstr _   = abstractConstr "ModuleName"-  gunfold _ _  = error "gunfold"-  dataTypeOf _ = mkNoRepType "ModuleName"--instance NFData ModuleName where-  rnf x = x `seq` ()--stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering--- ^ Compares module names lexically, rather than by their 'Unique's-stableModuleNameCmp n1 n2 = moduleNameFS n1 `compare` moduleNameFS n2--pprModuleName :: ModuleName -> SDoc-pprModuleName (ModuleName nm) =-    getPprStyle $ \ sty ->-    if codeStyle sty-        then ztext (zEncodeFS nm)-        else ftext nm--moduleNameFS :: ModuleName -> FastString-moduleNameFS (ModuleName mod) = mod--moduleNameString :: ModuleName -> String-moduleNameString (ModuleName mod) = unpackFS mod---- | Get a string representation of a 'Module' that's unique and stable--- across recompilations.--- eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"-moduleStableString :: Module -> String-moduleStableString Module{..} =-  "$" ++ unitIdString moduleUnitId ++ "$" ++ moduleNameString moduleName--mkModuleName :: String -> ModuleName-mkModuleName s = ModuleName (mkFastString s)--mkModuleNameFS :: FastString -> ModuleName-mkModuleNameFS s = ModuleName s---- |Returns the string version of the module name, with dots replaced by slashes.----moduleNameSlashes :: ModuleName -> String-moduleNameSlashes = dots_to_slashes . moduleNameString-  where dots_to_slashes = map (\c -> if c == '.' then pathSeparator else c)---- |Returns the string version of the module name, with dots replaced by colons.----moduleNameColons :: ModuleName -> String-moduleNameColons = dots_to_colons . moduleNameString-  where dots_to_colons = map (\c -> if c == '.' then ':' else c)--{--************************************************************************-*                                                                      *-\subsection{A fully qualified module}-*                                                                      *-************************************************************************--}---- | A Module is a pair of a 'UnitId' and a 'ModuleName'.------ Module variables (i.e. @<H>@) which can be instantiated to a--- specific module at some later point in time are represented--- with 'moduleUnitId' set to 'holeUnitId' (this allows us to--- avoid having to make 'moduleUnitId' a partial operation.)----data Module = Module {-   moduleUnitId :: !UnitId,  -- pkg-1.0-   moduleName :: !ModuleName  -- A.B.C-  }-  deriving (Eq, Ord)---- | Calculate the free holes of a 'Module'.  If this set is non-empty,--- this module was defined in an indefinite library that had required--- signatures.------ If a module has free holes, that means that substitutions can operate on it;--- if it has no free holes, substituting over a module has no effect.-moduleFreeHoles :: Module -> UniqDSet ModuleName-moduleFreeHoles m-    | isHoleModule m = unitUniqDSet (moduleName m)-    | otherwise = unitIdFreeHoles (moduleUnitId m)---- | A 'Module' is definite if it has no free holes.-moduleIsDefinite :: Module -> Bool-moduleIsDefinite = isEmptyUniqDSet . moduleFreeHoles---- | Create a module variable at some 'ModuleName'.--- See Note [Representation of module/name variables]-mkHoleModule :: ModuleName -> Module-mkHoleModule = mkModule holeUnitId--instance Uniquable Module where-  getUnique (Module p n) = getUnique (unitIdFS p `appendFS` moduleNameFS n)--instance Outputable Module where-  ppr = pprModule--instance Binary Module where-  put_ bh (Module p n) = put_ bh p >> put_ bh n-  get bh = do p <- get bh; n <- get bh; return (Module p n)--instance Data Module where-  -- don't traverse?-  toConstr _   = abstractConstr "Module"-  gunfold _ _  = error "gunfold"-  dataTypeOf _ = mkNoRepType "Module"--instance NFData Module where-  rnf x = x `seq` ()---- | This gives a stable ordering, as opposed to the Ord instance which--- gives an ordering based on the 'Unique's of the components, which may--- not be stable from run to run of the compiler.-stableModuleCmp :: Module -> Module -> Ordering-stableModuleCmp (Module p1 n1) (Module p2 n2)-   = (p1 `stableUnitIdCmp`  p2) `thenCmp`-     (n1 `stableModuleNameCmp` n2)--mkModule :: UnitId -> ModuleName -> Module-mkModule = Module--pprModule :: Module -> SDoc-pprModule mod@(Module p n)  = getPprStyle doc- where-  doc sty-    | codeStyle sty =-        (if p == mainUnitId-                then empty -- never qualify the main package in code-                else ztext (zEncodeFS (unitIdFS p)) <> char '_')-            <> pprModuleName n-    | qualModule sty mod =-        if isHoleModule mod-            then angleBrackets (pprModuleName n)-            else ppr (moduleUnitId mod) <> char ':' <> pprModuleName n-    | otherwise =-        pprModuleName n--class ContainsModule t where-    extractModule :: t -> Module--class HasModule m where-    getModule :: m Module--instance DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module where-  fromDbModule (DbModule uid mod_name)  = mkModule uid mod_name-  fromDbModule (DbModuleVar mod_name)   = mkHoleModule mod_name-  fromDbUnitId (DbUnitId cid insts)     = newUnitId cid insts-  fromDbUnitId (DbInstalledUnitId iuid) = DefiniteUnitId (DefUnitId iuid)-  -- GHC never writes to the database, so it's not needed-  toDbModule = error "toDbModule: not implemented"-  toDbUnitId = error "toDbUnitId: not implemented"--{--************************************************************************-*                                                                      *-\subsection{ComponentId}-*                                                                      *-************************************************************************--}---- | A 'ComponentId' consists of the package name, package version, component--- ID, the transitive dependencies of the component, and other information to--- uniquely identify the source code and build configuration of a component.------ This used to be known as an 'InstalledPackageId', but a package can contain--- multiple components and a 'ComponentId' uniquely identifies a component--- within a package.  When a package only has one component, the 'ComponentId'--- coincides with the 'InstalledPackageId'-data ComponentId = ComponentId-   { componentIdRaw     :: FastString             -- ^ Raw-   , componentIdDetails :: Maybe ComponentDetails -- ^ Cache of component details retrieved from the DB-   }--instance Eq ComponentId where-   a == b = componentIdRaw a == componentIdRaw b--instance Ord ComponentId where-   compare a b = compare (componentIdRaw a) (componentIdRaw b)--data ComponentDetails = ComponentDetails-   { componentPackageName    :: String-   , componentPackageVersion :: Version-   , componentName           :: Maybe String-   , componentSourcePkdId    :: String-   }--instance BinaryStringRep ComponentId where-  fromStringRep bs = ComponentId (mkFastStringByteString bs) Nothing-  toStringRep (ComponentId s _) = bytesFS s--instance Uniquable ComponentId where-  getUnique (ComponentId n _) = getUnique n--instance Outputable ComponentId where-  ppr cid@(ComponentId fs _) =-    getPprStyle $ \sty ->-      if debugStyle sty-         then ftext fs-         else text (componentIdString cid)----{--************************************************************************-*                                                                      *-\subsection{UnitId}-*                                                                      *-************************************************************************--}---- | A unit identifier identifies a (possibly partially) instantiated--- library.  It is primarily used as part of 'Module', which in turn--- is used in 'Name', which is used to give names to entities when--- typechecking.------ There are two possible forms for a 'UnitId'.  It can be a--- 'DefiniteUnitId', in which case we just have a string that uniquely--- identifies some fully compiled, installed library we have on disk.--- However, when we are typechecking a library with missing holes,--- we may need to instantiate a library on the fly (in which case--- we don't have any on-disk representation.)  In that case, you--- have an 'IndefiniteUnitId', which explicitly records the--- instantiation, so that we can substitute over it.-data UnitId-    = IndefiniteUnitId {-# UNPACK #-} !IndefUnitId-    |   DefiniteUnitId {-# UNPACK #-} !DefUnitId--unitIdFS :: UnitId -> FastString-unitIdFS (IndefiniteUnitId x) = indefUnitIdFS x-unitIdFS (DefiniteUnitId (DefUnitId x)) = installedUnitIdFS x--unitIdKey :: UnitId -> Unique-unitIdKey (IndefiniteUnitId x) = indefUnitIdKey x-unitIdKey (DefiniteUnitId (DefUnitId x)) = installedUnitIdKey x---- | A unit identifier which identifies an indefinite--- library (with holes) that has been *on-the-fly* instantiated--- with a substitution 'indefUnitIdInsts'.  In fact, an indefinite--- unit identifier could have no holes, but we haven't gotten--- around to compiling the actual library yet.------ An indefinite unit identifier pretty-prints to something like--- @p[H=<H>,A=aimpl:A>]@ (@p@ is the 'ComponentId', and the--- brackets enclose the module substitution).-data IndefUnitId-    = IndefUnitId {-        -- | A private, uniquely identifying representation of-        -- a UnitId.  This string is completely private to GHC-        -- and is just used to get a unique; in particular, we don't use it for-        -- symbols (indefinite libraries are not compiled).-        indefUnitIdFS :: FastString,-        -- | Cached unique of 'unitIdFS'.-        indefUnitIdKey :: Unique,-        -- | The component identity of the indefinite library that-        -- is being instantiated.-        indefUnitIdComponentId :: !ComponentId,-        -- | The sorted (by 'ModuleName') instantiations of this library.-        indefUnitIdInsts :: ![(ModuleName, Module)],-        -- | A cache of the free module variables of 'unitIdInsts'.-        -- This lets us efficiently tell if a 'UnitId' has been-        -- fully instantiated (free module variables are empty)-        -- and whether or not a substitution can have any effect.-        indefUnitIdFreeHoles :: UniqDSet ModuleName-    }--instance Eq IndefUnitId where-  u1 == u2 = indefUnitIdKey u1 == indefUnitIdKey u2--instance Ord IndefUnitId where-  u1 `compare` u2 = indefUnitIdFS u1 `compare` indefUnitIdFS u2--instance Binary IndefUnitId where-  put_ bh indef = do-    put_ bh (indefUnitIdComponentId indef)-    put_ bh (indefUnitIdInsts indef)-  get bh = do-    cid   <- get bh-    insts <- get bh-    let fs = hashUnitId cid insts-    return IndefUnitId {-            indefUnitIdComponentId = cid,-            indefUnitIdInsts = insts,-            indefUnitIdFreeHoles = unionManyUniqDSets (map (moduleFreeHoles.snd) insts),-            indefUnitIdFS = fs,-            indefUnitIdKey = getUnique fs-           }---- | Create a new 'IndefUnitId' given an explicit module substitution.-newIndefUnitId :: ComponentId -> [(ModuleName, Module)] -> IndefUnitId-newIndefUnitId cid insts =-    IndefUnitId {-        indefUnitIdComponentId = cid,-        indefUnitIdInsts = sorted_insts,-        indefUnitIdFreeHoles = unionManyUniqDSets (map (moduleFreeHoles.snd) insts),-        indefUnitIdFS = fs,-        indefUnitIdKey = getUnique fs-    }-  where-     fs = hashUnitId cid sorted_insts-     sorted_insts = sortBy (stableModuleNameCmp `on` fst) insts---- | Injects an 'IndefUnitId' (indefinite library which--- was on-the-fly instantiated) to a 'UnitId' (either--- an indefinite or definite library).-indefUnitIdToUnitId :: DynFlags -> IndefUnitId -> UnitId-indefUnitIdToUnitId dflags iuid =-    -- NB: suppose that we want to compare the indefinite-    -- unit id p[H=impl:H] against p+abcd (where p+abcd-    -- happens to be the existing, installed version of-    -- p[H=impl:H].  If we *only* wrap in p[H=impl:H]-    -- IndefiniteUnitId, they won't compare equal; only-    -- after improvement will the equality hold.-    improveUnitId (getUnitInfoMap dflags) $-        IndefiniteUnitId iuid--data IndefModule = IndefModule {-        indefModuleUnitId :: IndefUnitId,-        indefModuleName   :: ModuleName-    } deriving (Eq, Ord)--instance Outputable IndefModule where-  ppr (IndefModule uid m) =-    ppr uid <> char ':' <> ppr m---- | Injects an 'IndefModule' to 'Module' (see also--- 'indefUnitIdToUnitId'.-indefModuleToModule :: DynFlags -> IndefModule -> Module-indefModuleToModule dflags (IndefModule iuid mod_name) =-    mkModule (indefUnitIdToUnitId dflags iuid) mod_name---- | An installed unit identifier identifies a library which has--- been installed to the package database.  These strings are--- provided to us via the @-this-unit-id@ flag.  The library--- in question may be definite or indefinite; if it is indefinite,--- none of the holes have been filled (we never install partially--- instantiated libraries.)  Put another way, an installed unit id--- is either fully instantiated, or not instantiated at all.------ Installed unit identifiers look something like @p+af23SAj2dZ219@,--- or maybe just @p@ if they don't use Backpack.-newtype InstalledUnitId =-    InstalledUnitId {-      -- | The full hashed unit identifier, including the component id-      -- and the hash.-      installedUnitIdFS :: FastString-    }--instance Binary InstalledUnitId where-  put_ bh (InstalledUnitId fs) = put_ bh fs-  get bh = do fs <- get bh; return (InstalledUnitId fs)--instance BinaryStringRep InstalledUnitId where-  fromStringRep bs = InstalledUnitId (mkFastStringByteString bs)-  -- GHC doesn't write to database-  toStringRep   = error "BinaryStringRep InstalledUnitId: not implemented"--instance Eq InstalledUnitId where-    uid1 == uid2 = installedUnitIdKey uid1 == installedUnitIdKey uid2--instance Ord InstalledUnitId where-    u1 `compare` u2 = installedUnitIdFS u1 `compare` installedUnitIdFS u2--instance Uniquable InstalledUnitId where-    getUnique = installedUnitIdKey--instance Outputable InstalledUnitId where-    ppr uid@(InstalledUnitId fs) =-        getPprStyle $ \sty ->-        sdocWithDynFlags $ \dflags ->-          case displayInstalledUnitId (getPackageState dflags) uid of-            Just str | not (debugStyle sty) -> text str-            _ -> ftext fs--installedUnitIdKey :: InstalledUnitId -> Unique-installedUnitIdKey = getUnique . installedUnitIdFS---- | Lossy conversion to the on-disk 'InstalledUnitId' for a component.-toInstalledUnitId :: UnitId -> InstalledUnitId-toInstalledUnitId (DefiniteUnitId (DefUnitId iuid)) = iuid-toInstalledUnitId (IndefiniteUnitId indef) =-    componentIdToInstalledUnitId (indefUnitIdComponentId indef)--installedUnitIdString :: InstalledUnitId -> String-installedUnitIdString = unpackFS . installedUnitIdFS--instance Outputable IndefUnitId where-    ppr uid =-      -- getPprStyle $ \sty ->-      ppr cid <>-        (if not (null insts) -- pprIf-          then-            brackets (hcat-                (punctuate comma $-                    [ ppr modname <> text "=" <> ppr m-                    | (modname, m) <- insts]))-          else empty)-     where-      cid   = indefUnitIdComponentId uid-      insts = indefUnitIdInsts uid---- | A 'InstalledModule' is a 'Module' which contains a 'InstalledUnitId'.-data InstalledModule = InstalledModule {-   installedModuleUnitId :: !InstalledUnitId,-   installedModuleName :: !ModuleName-  }-  deriving (Eq, Ord)--instance Outputable InstalledModule where-  ppr (InstalledModule p n) =-    ppr p <> char ':' <> pprModuleName n--fsToInstalledUnitId :: FastString -> InstalledUnitId-fsToInstalledUnitId fs = InstalledUnitId fs--componentIdToInstalledUnitId :: ComponentId -> InstalledUnitId-componentIdToInstalledUnitId (ComponentId fs _) = fsToInstalledUnitId fs--stringToInstalledUnitId :: String -> InstalledUnitId-stringToInstalledUnitId = fsToInstalledUnitId . mkFastString---- | Test if a 'Module' corresponds to a given 'InstalledModule',--- modulo instantiation.-installedModuleEq :: InstalledModule -> Module -> Bool-installedModuleEq imod mod =-    fst (splitModuleInsts mod) == imod---- | Test if a 'UnitId' corresponds to a given 'InstalledUnitId',--- modulo instantiation.-installedUnitIdEq :: InstalledUnitId -> UnitId -> Bool-installedUnitIdEq iuid uid =-    fst (splitUnitIdInsts uid) == iuid---- | A 'DefUnitId' is an 'InstalledUnitId' with the invariant that--- it only refers to a definite library; i.e., one we have generated--- code for.-newtype DefUnitId = DefUnitId { unDefUnitId :: InstalledUnitId }-    deriving (Eq, Ord)--instance Outputable DefUnitId where-    ppr (DefUnitId uid) = ppr uid--instance Binary DefUnitId where-    put_ bh (DefUnitId uid) = put_ bh uid-    get bh = do uid <- get bh; return (DefUnitId uid)---- | A map keyed off of 'InstalledModule'-newtype InstalledModuleEnv elt = InstalledModuleEnv (Map InstalledModule elt)--emptyInstalledModuleEnv :: InstalledModuleEnv a-emptyInstalledModuleEnv = InstalledModuleEnv Map.empty--lookupInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> Maybe a-lookupInstalledModuleEnv (InstalledModuleEnv e) m = Map.lookup m e--extendInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> a -> InstalledModuleEnv a-extendInstalledModuleEnv (InstalledModuleEnv e) m x = InstalledModuleEnv (Map.insert m x e)--filterInstalledModuleEnv :: (InstalledModule -> a -> Bool) -> InstalledModuleEnv a -> InstalledModuleEnv a-filterInstalledModuleEnv f (InstalledModuleEnv e) =-  InstalledModuleEnv (Map.filterWithKey f e)--delInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> InstalledModuleEnv a-delInstalledModuleEnv (InstalledModuleEnv e) m = InstalledModuleEnv (Map.delete m e)---- Note [UnitId to InstalledUnitId improvement]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- Just because a UnitId is definite (has no holes) doesn't--- mean it's necessarily a InstalledUnitId; it could just be--- that over the course of renaming UnitIds on the fly--- while typechecking an indefinite library, we--- ended up with a fully instantiated unit id with no hash,--- since we haven't built it yet.  This is fine.------ However, if there is a hashed unit id for this instantiation--- in the package database, we *better use it*, because--- that hashed unit id may be lurking in another interface,--- and chaos will ensue if we attempt to compare the two--- (the unitIdFS for a UnitId never corresponds to a Cabal-provided--- hash of a compiled instantiated library).------ There is one last niggle: improvement based on the package database means--- that we might end up developing on a package that is not transitively--- depended upon by the packages the user specified directly via command line--- flags.  This could lead to strange and difficult to understand bugs if those--- instantiations are out of date.  The solution is to only improve a--- unit id if the new unit id is part of the 'preloadClosure'; i.e., the--- closure of all the packages which were explicitly specified.---- | Retrieve the set of free holes of a 'UnitId'.-unitIdFreeHoles :: UnitId -> UniqDSet ModuleName-unitIdFreeHoles (IndefiniteUnitId x) = indefUnitIdFreeHoles x--- Hashed unit ids are always fully instantiated-unitIdFreeHoles (DefiniteUnitId _) = emptyUniqDSet--instance Show UnitId where-    show = unitIdString---- | A 'UnitId' is definite if it has no free holes.-unitIdIsDefinite :: UnitId -> Bool-unitIdIsDefinite = isEmptyUniqDSet . unitIdFreeHoles---- | Generate a uniquely identifying 'FastString' for a unit--- identifier.  This is a one-way function.  You can rely on one special--- property: if a unit identifier is in most general form, its 'FastString'--- coincides with its 'ComponentId'.  This hash is completely internal--- to GHC and is not used for symbol names or file paths.-hashUnitId :: ComponentId -> [(ModuleName, Module)] -> FastString-hashUnitId cid sorted_holes =-    mkFastStringByteString-  . fingerprintUnitId (toStringRep cid)-  $ rawHashUnitId sorted_holes---- | Generate a hash for a sorted module substitution.-rawHashUnitId :: [(ModuleName, Module)] -> Fingerprint-rawHashUnitId sorted_holes =-    fingerprintByteString-  . BS.concat $ do-        (m, b) <- sorted_holes-        [ toStringRep m,                BS.Char8.singleton ' ',-          bytesFS (unitIdFS (moduleUnitId b)), BS.Char8.singleton ':',-          toStringRep (moduleName b),   BS.Char8.singleton '\n']--fingerprintUnitId :: BS.ByteString -> Fingerprint -> BS.ByteString-fingerprintUnitId prefix (Fingerprint a b)-    = BS.concat-    $ [ prefix-      , BS.Char8.singleton '-'-      , BS.Char8.pack (toBase62Padded a)-      , BS.Char8.pack (toBase62Padded b) ]---- | Create a new, un-hashed unit identifier.-newUnitId :: ComponentId -> [(ModuleName, Module)] -> UnitId-newUnitId cid [] = newSimpleUnitId cid -- TODO: this indicates some latent bug...-newUnitId cid insts = IndefiniteUnitId $ newIndefUnitId cid insts--pprUnitId :: UnitId -> SDoc-pprUnitId (DefiniteUnitId uid) = ppr uid-pprUnitId (IndefiniteUnitId uid) = ppr uid--instance Eq UnitId where-  uid1 == uid2 = unitIdKey uid1 == unitIdKey uid2--instance Uniquable UnitId where-  getUnique = unitIdKey--instance Ord UnitId where-  nm1 `compare` nm2 = stableUnitIdCmp nm1 nm2--instance Data UnitId where-  -- don't traverse?-  toConstr _   = abstractConstr "UnitId"-  gunfold _ _  = error "gunfold"-  dataTypeOf _ = mkNoRepType "UnitId"--instance NFData UnitId where-  rnf x = x `seq` ()--stableUnitIdCmp :: UnitId -> UnitId -> Ordering--- ^ Compares package ids lexically, rather than by their 'Unique's-stableUnitIdCmp p1 p2 = unitIdFS p1 `compare` unitIdFS p2--instance Outputable UnitId where-   ppr pk = pprUnitId pk---- Performance: would prefer to have a NameCache like thing-instance Binary UnitId where-  put_ bh (DefiniteUnitId def_uid) = do-    putByte bh 0-    put_ bh def_uid-  put_ bh (IndefiniteUnitId indef_uid) = do-    putByte bh 1-    put_ bh indef_uid-  get bh = do b <- getByte bh-              case b of-                0 -> fmap DefiniteUnitId   (get bh)-                _ -> fmap IndefiniteUnitId (get bh)--instance Binary ComponentId where-  put_ bh (ComponentId fs _) = put_ bh fs-  get bh = do { fs <- get bh; return (ComponentId fs Nothing) }---- | Create a new simple unit identifier (no holes) from a 'ComponentId'.-newSimpleUnitId :: ComponentId -> UnitId-newSimpleUnitId (ComponentId fs _) = fsToUnitId fs---- | Create a new simple unit identifier from a 'FastString'.  Internally,--- this is primarily used to specify wired-in unit identifiers.-fsToUnitId :: FastString -> UnitId-fsToUnitId = DefiniteUnitId . DefUnitId . InstalledUnitId--stringToUnitId :: String -> UnitId-stringToUnitId = fsToUnitId . mkFastString--unitIdString :: UnitId -> String-unitIdString = unpackFS . unitIdFS--{--************************************************************************-*                                                                      *-                        Hole substitutions-*                                                                      *-************************************************************************--}---- | Substitution on module variables, mapping module names to module--- identifiers.-type ShHoleSubst = ModuleNameEnv Module---- | Substitutes holes in a 'Module'.  NOT suitable for being called--- directly on a 'nameModule', see Note [Representation of module/name variable].--- @p[A=<A>]:B@ maps to @p[A=q():A]:B@ with @A=q():A@;--- similarly, @<A>@ maps to @q():A@.-renameHoleModule :: DynFlags -> ShHoleSubst -> Module -> Module-renameHoleModule dflags = renameHoleModule' (getUnitInfoMap dflags)---- | Substitutes holes in a 'UnitId', suitable for renaming when--- an include occurs; see Note [Representation of module/name variable].------ @p[A=<A>]@ maps to @p[A=<B>]@ with @A=<B>@.-renameHoleUnitId :: DynFlags -> ShHoleSubst -> UnitId -> UnitId-renameHoleUnitId dflags = renameHoleUnitId' (getUnitInfoMap dflags)---- | Like 'renameHoleModule', but requires only 'UnitInfoMap'--- so it can be used by "Packages".-renameHoleModule' :: UnitInfoMap -> ShHoleSubst -> Module -> Module-renameHoleModule' pkg_map env m-  | not (isHoleModule m) =-        let uid = renameHoleUnitId' pkg_map env (moduleUnitId m)-        in mkModule uid (moduleName m)-  | Just m' <- lookupUFM env (moduleName m) = m'-  -- NB m = <Blah>, that's what's in scope.-  | otherwise = m---- | Like 'renameHoleUnitId, but requires only 'UnitInfoMap'--- so it can be used by "Packages".-renameHoleUnitId' :: UnitInfoMap -> ShHoleSubst -> UnitId -> UnitId-renameHoleUnitId' pkg_map env uid =-    case uid of-      (IndefiniteUnitId-        IndefUnitId{ indefUnitIdComponentId = cid-                   , indefUnitIdInsts       = insts-                   , indefUnitIdFreeHoles   = fh })-          -> if isNullUFM (intersectUFM_C const (udfmToUfm (getUniqDSet fh)) env)-                then uid-                -- Functorially apply the substitution to the instantiation,-                -- then check the 'UnitInfoMap' to see if there is-                -- a compiled version of this 'UnitId' we can improve to.-                -- See Note [UnitId to InstalledUnitId] improvement-                else improveUnitId pkg_map $-                        newUnitId cid-                            (map (\(k,v) -> (k, renameHoleModule' pkg_map env v)) insts)-      _ -> uid---- | Given a possibly on-the-fly instantiated module, split it into--- a 'Module' that we definitely can find on-disk, as well as an--- instantiation if we need to instantiate it on the fly.  If the--- instantiation is @Nothing@ no on-the-fly renaming is needed.-splitModuleInsts :: Module -> (InstalledModule, Maybe IndefModule)-splitModuleInsts m =-    let (uid, mb_iuid) = splitUnitIdInsts (moduleUnitId m)-    in (InstalledModule uid (moduleName m),-        fmap (\iuid -> IndefModule iuid (moduleName m)) mb_iuid)---- | See 'splitModuleInsts'.-splitUnitIdInsts :: UnitId -> (InstalledUnitId, Maybe IndefUnitId)-splitUnitIdInsts (IndefiniteUnitId iuid) =-    (componentIdToInstalledUnitId (indefUnitIdComponentId iuid), Just iuid)-splitUnitIdInsts (DefiniteUnitId (DefUnitId uid)) = (uid, Nothing)--generalizeIndefUnitId :: IndefUnitId -> IndefUnitId-generalizeIndefUnitId IndefUnitId{ indefUnitIdComponentId = cid-                                 , indefUnitIdInsts = insts } =-    newIndefUnitId cid (map (\(m,_) -> (m, mkHoleModule m)) insts)--generalizeIndefModule :: IndefModule -> IndefModule-generalizeIndefModule (IndefModule uid n) = IndefModule (generalizeIndefUnitId uid) n--parseModuleName :: ReadP ModuleName-parseModuleName = fmap mkModuleName-                $ Parse.munch1 (\c -> isAlphaNum c || c `elem` "_.")--parseUnitId :: ReadP UnitId-parseUnitId = parseFullUnitId <++ parseDefiniteUnitId <++ parseSimpleUnitId-  where-    parseFullUnitId = do-        cid <- parseComponentId-        insts <- parseModSubst-        return (newUnitId cid insts)-    parseDefiniteUnitId = do-        s <- Parse.munch1 (\c -> isAlphaNum c || c `elem` "-_.+")-        return (stringToUnitId s)-    parseSimpleUnitId = do-        cid <- parseComponentId-        return (newSimpleUnitId cid)--parseComponentId :: ReadP ComponentId-parseComponentId = (flip ComponentId Nothing . mkFastString)  `fmap` Parse.munch1 abi_char-   where abi_char c = isAlphaNum c || c `elem` "-_."--parseModuleId :: ReadP Module-parseModuleId = parseModuleVar <++ parseModule-    where-      parseModuleVar = do-        _ <- Parse.char '<'-        modname <- parseModuleName-        _ <- Parse.char '>'-        return (mkHoleModule modname)-      parseModule = do-        uid <- parseUnitId-        _ <- Parse.char ':'-        modname <- parseModuleName-        return (mkModule uid modname)--parseModSubst :: ReadP [(ModuleName, Module)]-parseModSubst = Parse.between (Parse.char '[') (Parse.char ']')-      . flip Parse.sepBy (Parse.char ',')-      $ do k <- parseModuleName-           _ <- Parse.char '='-           v <- parseModuleId-           return (k, v)---{--Note [Wired-in packages]-~~~~~~~~~~~~~~~~~~~~~~~~--Certain packages are known to the compiler, in that we know about certain-entities that reside in these packages, and the compiler needs to-declare static Modules and Names that refer to these packages.  Hence-the wired-in packages can't include version numbers in their package UnitId,-since we don't want to bake the version numbers of these packages into GHC.--So here's the plan.  Wired-in packages are still versioned as-normal in the packages database, and you can still have multiple-versions of them installed. To the user, everything looks normal.--However, for each invocation of GHC, only a single instance of each wired-in-package will be recognised (the desired one is selected via-@-package@\/@-hide-package@), and GHC will internally pretend that it has the-*unversioned* 'UnitId', including in .hi files and object file symbols.--Unselected versions of wired-in packages will be ignored, as will any other-package that depends directly or indirectly on it (much as if you-had used @-ignore-package@).--The affected packages are compiled with, e.g., @-this-unit-id base@, so that-the symbols in the object files have the unversioned unit id in their name.--Make sure you change 'Packages.findWiredInPackages' if you add an entry here.--For `integer-gmp`/`integer-simple` we also change the base name to-`integer-wired-in`, but this is fundamentally no different.-See Note [The integer library] in PrelNames.--}--integerUnitId, primUnitId,-  baseUnitId, rtsUnitId,-  thUnitId, mainUnitId, thisGhcUnitId, interactiveUnitId  :: UnitId-primUnitId        = fsToUnitId (fsLit "ghc-prim")-integerUnitId     = fsToUnitId (fsLit "integer-wired-in")-   -- See Note [The integer library] in PrelNames-baseUnitId        = fsToUnitId (fsLit "base")-rtsUnitId         = fsToUnitId (fsLit "rts")-thUnitId          = fsToUnitId (fsLit "template-haskell")-thisGhcUnitId     = fsToUnitId (fsLit "ghc")-interactiveUnitId = fsToUnitId (fsLit "interactive")---- | This is the package Id for the current program.  It is the default--- package Id if you don't specify a package name.  We don't add this prefix--- to symbol names, since there can be only one main package per program.-mainUnitId      = fsToUnitId (fsLit "main")---- | This is a fake package id used to provide identities to any un-implemented--- signatures.  The set of hole identities is global over an entire compilation.--- Don't use this directly: use 'mkHoleModule' or 'isHoleModule' instead.--- See Note [Representation of module/name variables]-holeUnitId :: UnitId-holeUnitId      = fsToUnitId (fsLit "hole")--isInteractiveModule :: Module -> Bool-isInteractiveModule mod = moduleUnitId mod == interactiveUnitId---- Note [Representation of module/name variables]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- In our ICFP'16, we use <A> to represent module holes, and {A.T} to represent--- name holes.  This could have been represented by adding some new cases--- to the core data types, but this would have made the existing 'nameModule'--- and 'moduleUnitId' partial, which would have required a lot of modifications--- to existing code.------ Instead, we adopted the following encoding scheme:------      <A>   ===> hole:A---      {A.T} ===> hole:A.T------ This encoding is quite convenient, but it is also a bit dangerous too,--- because if you have a 'hole:A' you need to know if it's actually a--- 'Module' or just a module stored in a 'Name'; these two cases must be--- treated differently when doing substitutions.  'renameHoleModule'--- and 'renameHoleUnitId' assume they are NOT operating on a--- 'Name'; 'NameShape' handles name substitutions exclusively.--isHoleModule :: Module -> Bool-isHoleModule mod = moduleUnitId mod == holeUnitId--wiredInUnitIds :: [UnitId]-wiredInUnitIds = [ primUnitId,-                       integerUnitId,-                       baseUnitId,-                       rtsUnitId,-                       thUnitId,-                       thisGhcUnitId ]--{--************************************************************************-*                                                                      *-\subsection{@ModuleEnv@s}-*                                                                      *-************************************************************************--}---- | A map keyed off of 'Module's-newtype ModuleEnv elt = ModuleEnv (Map NDModule elt)--{--Note [ModuleEnv performance and determinism]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-To prevent accidental reintroduction of nondeterminism the Ord instance-for Module was changed to not depend on Unique ordering and to use the-lexicographic order. This is potentially expensive, but when measured-there was no difference in performance.--To be on the safe side and not pessimize ModuleEnv uses nondeterministic-ordering on Module and normalizes by doing the lexicographic sort when-turning the env to a list.-See Note [Unique Determinism] for more information about the source of-nondeterminismand and Note [Deterministic UniqFM] for explanation of why-it matters for maps.--}--newtype NDModule = NDModule { unNDModule :: Module }-  deriving Eq-  -- A wrapper for Module with faster nondeterministic Ord.-  -- Don't export, See [ModuleEnv performance and determinism]--instance Ord NDModule where-  compare (NDModule (Module p1 n1)) (NDModule (Module p2 n2)) =-    (getUnique p1 `nonDetCmpUnique` getUnique p2) `thenCmp`-    (getUnique n1 `nonDetCmpUnique` getUnique n2)--filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a-filterModuleEnv f (ModuleEnv e) =-  ModuleEnv (Map.filterWithKey (f . unNDModule) e)--elemModuleEnv :: Module -> ModuleEnv a -> Bool-elemModuleEnv m (ModuleEnv e) = Map.member (NDModule m) e--extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a-extendModuleEnv (ModuleEnv e) m x = ModuleEnv (Map.insert (NDModule m) x e)--extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a-                    -> ModuleEnv a-extendModuleEnvWith f (ModuleEnv e) m x =-  ModuleEnv (Map.insertWith f (NDModule m) x e)--extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a-extendModuleEnvList (ModuleEnv e) xs =-  ModuleEnv (Map.insertList [(NDModule k, v) | (k,v) <- xs] e)--extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)]-                      -> ModuleEnv a-extendModuleEnvList_C f (ModuleEnv e) xs =-  ModuleEnv (Map.insertListWith f [(NDModule k, v) | (k,v) <- xs] e)--plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a-plusModuleEnv_C f (ModuleEnv e1) (ModuleEnv e2) =-  ModuleEnv (Map.unionWith f e1 e2)--delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a-delModuleEnvList (ModuleEnv e) ms =-  ModuleEnv (Map.deleteList (map NDModule ms) e)--delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a-delModuleEnv (ModuleEnv e) m = ModuleEnv (Map.delete (NDModule m) e)--plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a-plusModuleEnv (ModuleEnv e1) (ModuleEnv e2) = ModuleEnv (Map.union e1 e2)--lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a-lookupModuleEnv (ModuleEnv e) m = Map.lookup (NDModule m) e--lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a-lookupWithDefaultModuleEnv (ModuleEnv e) x m =-  Map.findWithDefault x (NDModule m) e--mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b-mapModuleEnv f (ModuleEnv e) = ModuleEnv (Map.mapWithKey (\_ v -> f v) e)--mkModuleEnv :: [(Module, a)] -> ModuleEnv a-mkModuleEnv xs = ModuleEnv (Map.fromList [(NDModule k, v) | (k,v) <- xs])--emptyModuleEnv :: ModuleEnv a-emptyModuleEnv = ModuleEnv Map.empty--moduleEnvKeys :: ModuleEnv a -> [Module]-moduleEnvKeys (ModuleEnv e) = sort $ map unNDModule $ Map.keys e-  -- See Note [ModuleEnv performance and determinism]--moduleEnvElts :: ModuleEnv a -> [a]-moduleEnvElts e = map snd $ moduleEnvToList e-  -- See Note [ModuleEnv performance and determinism]--moduleEnvToList :: ModuleEnv a -> [(Module, a)]-moduleEnvToList (ModuleEnv e) =-  sortBy (comparing fst) [(m, v) | (NDModule m, v) <- Map.toList e]-  -- See Note [ModuleEnv performance and determinism]--unitModuleEnv :: Module -> a -> ModuleEnv a-unitModuleEnv m x = ModuleEnv (Map.singleton (NDModule m) x)--isEmptyModuleEnv :: ModuleEnv a -> Bool-isEmptyModuleEnv (ModuleEnv e) = Map.null e---- | A set of 'Module's-type ModuleSet = Set NDModule--mkModuleSet :: [Module] -> ModuleSet-mkModuleSet = Set.fromList . coerce--extendModuleSet :: ModuleSet -> Module -> ModuleSet-extendModuleSet s m = Set.insert (NDModule m) s--extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet-extendModuleSetList s ms = foldl' (coerce . flip Set.insert) s ms--emptyModuleSet :: ModuleSet-emptyModuleSet = Set.empty--moduleSetElts :: ModuleSet -> [Module]-moduleSetElts = sort . coerce . Set.toList--elemModuleSet :: Module -> ModuleSet -> Bool-elemModuleSet = Set.member . coerce--intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet-intersectModuleSet = coerce Set.intersection--minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet-minusModuleSet = coerce Set.difference--delModuleSet :: ModuleSet -> Module -> ModuleSet-delModuleSet = coerce (flip Set.delete)--unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet-unionModuleSet = coerce Set.union--unitModuleSet :: Module -> ModuleSet-unitModuleSet = coerce Set.singleton--{--A ModuleName has a Unique, so we can build mappings of these using-UniqFM.--}---- | A map keyed off of 'ModuleName's (actually, their 'Unique's)-type ModuleNameEnv elt = UniqFM elt----- | A map keyed off of 'ModuleName's (actually, their 'Unique's)--- Has deterministic folds and can be deterministically converted to a list-type DModuleNameEnv elt = UniqDFM elt
− compiler/GHC/Types/Module.hs-boot 
@@ -1,13 +0,0 @@-module GHC.Types.Module where--import GhcPrelude--data Module-data ModuleName-data UnitId-data InstalledUnitId-data ComponentId--moduleName :: Module -> ModuleName-moduleUnitId :: Module -> UnitId-unitIdString :: UnitId -> String
compiler/GHC/Types/Name.hs view
@@ -79,19 +79,19 @@         module GHC.Types.Name.Occurrence     ) where -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-} GHC.Core.TyCo.Rep( TyThing )  import GHC.Types.Name.Occurrence-import GHC.Types.Module+import GHC.Unit.Module import GHC.Types.SrcLoc import GHC.Types.Unique-import Util-import Maybes-import Binary-import FastString-import Outputable+import GHC.Utils.Misc+import GHC.Data.Maybe+import GHC.Utils.Binary+import GHC.Data.FastString+import GHC.Utils.Outputable  import Control.DeepSeq import Data.Data@@ -282,12 +282,12 @@ -- True if the Name is defined in module of this package nameIsHomePackage this_mod   = \nm -> case n_sort nm of-              External nm_mod    -> moduleUnitId nm_mod == this_pkg-              WiredIn nm_mod _ _ -> moduleUnitId nm_mod == this_pkg+              External nm_mod    -> moduleUnit nm_mod == this_pkg+              WiredIn nm_mod _ _ -> moduleUnit nm_mod == this_pkg               Internal -> True               System   -> False   where-    this_pkg = moduleUnitId this_mod+    this_pkg = moduleUnit this_mod  nameIsHomePackageImport :: Module -> Name -> Bool -- True if the Name is defined in module of this package@@ -296,17 +296,17 @@   = \nm -> case nameModule_maybe nm of               Nothing -> False               Just nm_mod -> nm_mod /= this_mod-                          && moduleUnitId nm_mod == this_pkg+                          && moduleUnit nm_mod == this_pkg   where-    this_pkg = moduleUnitId this_mod+    this_pkg = moduleUnit this_mod  -- | Returns True if the Name comes from some other package: neither this -- package nor the interactive package.-nameIsFromExternalPackage :: UnitId -> Name -> Bool-nameIsFromExternalPackage this_pkg name+nameIsFromExternalPackage :: Unit -> Name -> Bool+nameIsFromExternalPackage this_unit name   | Just mod <- nameModule_maybe name-  , moduleUnitId mod /= this_pkg    -- Not this package-  , not (isInteractiveModule mod)       -- Not the 'interactive' package+  , moduleUnit mod /= this_unit   -- Not the current unit+  , not (isInteractiveModule mod) -- Not the 'interactive' package   = True   | otherwise   = False@@ -592,7 +592,7 @@     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-      NameNotInScope2  -> ppr (moduleUnitId mod) <> colon     -- Module not in+      NameNotInScope2  -> ppr (moduleUnit mod) <> colon     -- Module not in                           <> ppr (moduleName mod) <> dot          -- scope either       NameUnqual       -> empty                   -- In scope unqualified
compiler/GHC/Types/Name.hs-boot view
@@ -1,5 +1,5 @@ module GHC.Types.Name where -import GhcPrelude ()+import GHC.Prelude ()  data Name
compiler/GHC/Types/Name/Cache.hs view
@@ -10,15 +10,15 @@     , NameCache(..), OrigNameCache     ) where -import GhcPrelude+import GHC.Prelude -import GHC.Types.Module+import GHC.Unit.Module import GHC.Types.Name import GHC.Types.Unique.Supply-import TysWiredIn-import Util-import Outputable-import PrelNames+import GHC.Builtin.Types+import GHC.Utils.Misc+import GHC.Utils.Outputable+import GHC.Builtin.Names  #include "HsVersions.h" @@ -79,7 +79,7 @@ lookupOrigNameCache nc mod occ   | mod == gHC_TYPES || mod == gHC_PRIM || mod == gHC_TUPLE   , Just name <- isBuiltInOcc_maybe occ-  =     -- See Note [Known-key names], 3(c) in PrelNames+  =     -- See Note [Known-key names], 3(c) in GHC.Builtin.Names         -- Special case for tuples; there are too many         -- of them to pre-populate the original-name cache     Just name
compiler/GHC/Types/Name/Env.hs view
@@ -37,13 +37,13 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import Digraph+import GHC.Data.Graph.Directed import GHC.Types.Name import GHC.Types.Unique.FM import GHC.Types.Unique.DFM-import Maybes+import GHC.Data.Maybe  {- ************************************************************************@@ -60,7 +60,7 @@ The order of lists that get_defs and get_uses return doesn't matter, as these are only used to construct the edges, and stronglyConnCompFromEdgedVertices is deterministic even when the edges are not in deterministic order as explained-in Note [Deterministic SCC] in Digraph.+in Note [Deterministic SCC] in GHC.Data.Graph.Directed. -}  depAnal :: forall node.
compiler/GHC/Types/Name/Occurrence.hs view
@@ -101,17 +101,17 @@         FastStringEnv, emptyFsEnv, lookupFsEnv, extendFsEnv, mkFsEnv     ) where -import GhcPrelude+import GHC.Prelude -import Util+import GHC.Utils.Misc import GHC.Types.Unique import GHC.Types.Unique.FM import GHC.Types.Unique.Set-import FastString-import FastStringEnv-import Outputable+import GHC.Data.FastString+import GHC.Data.FastString.Env+import GHC.Utils.Outputable import GHC.Utils.Lexeme-import Binary+import GHC.Utils.Binary import Control.DeepSeq import Data.Char import Data.Data@@ -597,7 +597,7 @@  -- | Is an 'OccName' one of a Typeable @TyCon@ or @Module@ binding? -- This is needed as these bindings are renamed differently.--- See Note [Grand plan for Typeable] in TcTypeable.+-- See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable. isTypeableBindOcc :: OccName -> Bool isTypeableBindOcc occ =    case occNameString occ of@@ -639,7 +639,7 @@ mkTag2ConOcc        = mk_simple_deriv varName  "$tag2con_" mkMaxTagOcc         = mk_simple_deriv varName  "$maxtag_" --- TyConRepName stuff; see Note [Grand plan for Typeable] in TcTypeable+-- TyConRepName stuff; see Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable mkTyConRepOcc occ = mk_simple_deriv varName prefix occ   where     prefix | isDataOcc occ = "$tc'"@@ -729,7 +729,7 @@ error messages from the type checker when we print the function name or pattern of an instance-decl binding.  Why? Because the binding is zapped to use the method name in place of the selector name.-(See TcClassDcl.tcMethodBind)+(See GHC.Tc.TyCl.Class.tcMethodBind)  The way it is now, -ddump-xx output may look confusing, but you can always say -dppr-debug to get the uniques.
compiler/GHC/Types/Name/Occurrence.hs-boot view
@@ -1,5 +1,5 @@ module GHC.Types.Name.Occurrence where -import GhcPrelude ()+import GHC.Prelude ()  data OccName
compiler/GHC/Types/Name/Reader.hs view
@@ -70,21 +70,21 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude -import GHC.Types.Module+import GHC.Unit.Module import GHC.Types.Name import GHC.Types.Avail import GHC.Types.Name.Set-import Maybes+import GHC.Data.Maybe import GHC.Types.SrcLoc as SrcLoc-import FastString+import GHC.Data.FastString import GHC.Types.FieldLabel-import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique import GHC.Types.Unique.FM import GHC.Types.Unique.Set-import Util+import GHC.Utils.Misc import GHC.Types.Name.Env  import Data.Data@@ -117,7 +117,7 @@ --           'ApiAnnotation.AnnVal' --           'ApiAnnotation.AnnTilde', --- For details on above see note [Api annotations] in ApiAnnotation+-- For details on above see note [Api annotations] in GHC.Parser.Annotation data RdrName   = Unqual OccName         -- ^ Unqualified  name@@ -416,7 +416,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ With Template Haskell we can make local bindings that have Exact Names. Computing shadowing etc may use elemLocalRdrEnv (at least it certainly-does so in GHC.Rename.Types.bindHsQTyVars), so for an Exact Name we must consult+does so in GHC.Rename.HsType.bindHsQTyVars), so for an Exact Name we must consult the in-scope-name-set.
compiler/GHC/Types/Name/Set.hs view
@@ -33,10 +33,10 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Name-import OrdList+import GHC.Data.OrdList import GHC.Types.Unique.Set import Data.List (sortBy)
compiler/GHC/Types/RepType.hs view
@@ -23,19 +23,19 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Basic (Arity, RepArity) import GHC.Core.DataCon-import Outputable-import PrelNames+import GHC.Utils.Outputable+import GHC.Builtin.Names import GHC.Core.Coercion import GHC.Core.TyCon import GHC.Core.TyCo.Rep import GHC.Core.Type-import Util-import TysPrim-import {-# SOURCE #-} TysWiredIn ( anyTypeOfKind )+import GHC.Utils.Misc+import GHC.Builtin.Types.Prim+import {-# SOURCE #-} GHC.Builtin.Types ( anyTypeOfKind )  import Data.List (sort) import qualified Data.IntSet as IS@@ -366,7 +366,7 @@ It's all in 1-1 correspondence with PrimRep except for TupleRep and SumRep, which describe unboxed products and sums respectively. RuntimeRep is defined in the library ghc-prim:GHC.Types. It is also "wired-in" to GHC: see-TysWiredIn.runtimeRepTyCon. The unarisation pass, in GHC.Stg.Unarise, transforms the+GHC.Builtin.Types.runtimeRepTyCon. The unarisation pass, in GHC.Stg.Unarise, transforms the program, so that that every variable has a type that has a PrimRep. For example, unarisation transforms our utup function above, to take two Int arguments instead of one (# Int, Int #) argument.@@ -425,13 +425,13 @@ should be passed the TyCon produced by promoting one of the constructors of RuntimeRep into type-level data. The RuntimeRep promoted datacons are associated with a RuntimeRepInfo (stored directly in the PromotedDataCon-constructor of TyCon). This pairing happens in TysWiredIn. A RuntimeRepInfo+constructor of TyCon). This pairing happens in GHC.Builtin.Types. A RuntimeRepInfo usually(*) contains a function from [Type] to [PrimRep]: the [Type] are the arguments to the promoted datacon. These arguments are necessary for the TupleRep and SumRep constructors, so that this process can recur, producing a flattened list of PrimReps. Calling this extracted function happens in runtimeRepPrimRep; the functions themselves are defined in-tupleRepDataCon and sumRepDataCon, both in TysWiredIn.+tupleRepDataCon and sumRepDataCon, both in GHC.Builtin.Types.  The (*) above is to support vector representations. RuntimeRep refers to VecCount and VecElem, whose promoted datacons have nuggets of information@@ -454,9 +454,9 @@ (PromotedDataCon "TupleRep"), extracting a function that will produce the PrimReps. In example 1, this function is passed an empty list (the empty list of args to IntRep) and returns the PrimRep IntRep. (See the definition of runtimeRepSimpleDataCons in-TysWiredIn and its helper function mk_runtime_rep_dc.) Example 2 passes the promoted+GHC.Builtin.Types and its helper function mk_runtime_rep_dc.) Example 2 passes the promoted list as the one argument to the extracted function. The extracted function is defined-as prim_rep_fun within tupleRepDataCon in TysWiredIn. It takes one argument, decomposes+as prim_rep_fun within tupleRepDataCon in GHC.Builtin.Types. It takes one argument, decomposes the promoted list (with extractPromotedList), and then recurs back to runtimeRepPrimRep to process the LiftedRep and WordRep, concatentating the results.
compiler/GHC/Types/SrcLoc.hs view
@@ -106,12 +106,12 @@      ) where -import GhcPrelude+import GHC.Prelude -import Util-import Json-import Outputable-import FastString+import GHC.Utils.Misc+import GHC.Utils.Json+import GHC.Utils.Outputable+import GHC.Data.FastString  import Control.DeepSeq import Control.Applicative (liftA2)@@ -145,7 +145,7 @@ -- -- 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'.+-- GHC.Parser.Lexer update 'PsLoc' preserving 'BufPos'. -- -- The parser guarantees that 'BufPos' are monotonic. See #17632. newtype BufPos = BufPos { bufPos :: Int }@@ -305,7 +305,7 @@   | UnhelpfulSpan !FastString   -- Just a general indication                                 -- also used to indicate an empty span -  deriving (Eq, Show) -- Show is used by Lexer.x, because we+  deriving (Eq, Show) -- Show is used by GHC.Parser.Lexer, because we                       -- derive Show for Token  {- Note [Why Maybe BufPos]@@ -530,7 +530,7 @@   show (SrcLoc filename row col)       = "SrcLoc " ++ show filename ++ " " ++ show row ++ " " ++ show col --- Show is used by Lexer.x, because we derive Show for Token+-- Show is used by GHC.Parser.Lexer, because we derive Show for Token instance Show RealSrcSpan where   show span@(RealSrcSpan' file sl sc el ec)     | isPointRealSpan span
compiler/GHC/Types/Unique.hs view
@@ -75,12 +75,12 @@ #include "HsVersions.h" #include "Unique.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Basic-import FastString-import Outputable-import Util+import GHC.Data.FastString+import GHC.Utils.Outputable+import GHC.Utils.Misc  -- just for implementing a fast [0,61) -> Char function import GHC.Exts (indexCharOffAddr#, Char(..), Int(..))@@ -376,7 +376,7 @@ mkPreludeTyConUnique   :: Int -> Unique mkPreludeDataConUnique :: Arity -> Unique mkPrimOpIdUnique       :: Int -> Unique--- See Note [Primop wrappers] in PrimOp.hs.+-- See Note [Primop wrappers] in GHC.Builtin.PrimOps. mkPrimOpWrapperUnique  :: Int -> Unique mkPreludeMiscIdUnique  :: Int -> Unique mkCoVarUnique          :: Int -> Unique
compiler/GHC/Types/Unique/DFM.hs view
@@ -61,10 +61,10 @@         alwaysUnsafeUfmToUdfm,     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Unique ( Uniquable(..), Unique, getKey )-import Outputable+import GHC.Utils.Outputable  import qualified Data.IntMap as M import Data.Data
compiler/GHC/Types/Unique/DSet.hs view
@@ -37,9 +37,9 @@         mapUniqDSet     ) where -import GhcPrelude+import GHC.Prelude -import Outputable+import GHC.Utils.Outputable import GHC.Types.Unique.DFM import GHC.Types.Unique.Set import GHC.Types.Unique
compiler/GHC/Types/Unique/FM.hs view
@@ -71,10 +71,10 @@         pprUniqFM, pprUFM, pprUFMWithKeys, pluralUFM     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Unique ( Uniquable(..), Unique, getKey )-import Outputable+import GHC.Utils.Outputable  import qualified Data.IntMap as M import qualified Data.IntSet as S
compiler/GHC/Types/Unique/Set.hs view
@@ -46,12 +46,12 @@         nonDetFoldUniqSet_Directly     ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Unique.FM import GHC.Types.Unique import Data.Coerce-import Outputable+import GHC.Utils.Outputable import Data.Data import qualified Data.Semigroup as Semi
compiler/GHC/Types/Unique/Supply.hs view
@@ -33,14 +33,14 @@         initUniqSupply   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Types.Unique-import PlainPanic (panic)+import GHC.Utils.Panic.Plain (panic)  import GHC.IO -import MonadUtils+import GHC.Utils.Monad import Control.Monad import Data.Bits import Data.Char
compiler/GHC/Types/Var.hs view
@@ -89,20 +89,20 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import {-# SOURCE #-}   GHC.Core.TyCo.Rep( Type, Kind ) import {-# SOURCE #-}   GHC.Core.TyCo.Ppr( pprKind )-import {-# SOURCE #-}   TcType( TcTyVarDetails, pprTcTyVarDetails, vanillaSkolemTv )+import {-# SOURCE #-}   GHC.Tc.Utils.TcType( TcTyVarDetails, pprTcTyVarDetails, vanillaSkolemTv ) import {-# SOURCE #-}   GHC.Types.Id.Info( IdDetails, IdInfo, coVarDetails, isCoVarDetails,                                            vanillaIdInfo, pprIdDetails )  import GHC.Types.Name hiding (varName) import GHC.Types.Unique ( Uniquable, Unique, getKey, getUnique                         , mkUniqueGrimily, nonDetCmpUnique )-import Util-import Binary-import Outputable+import GHC.Utils.Misc+import GHC.Utils.Binary+import GHC.Utils.Outputable  import Data.Data @@ -611,7 +611,7 @@  mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar mkTcTyVar name kind details-  = -- NB: 'kind' may be a coercion kind; cf, 'TcMType.newMetaCoVar'+  = -- NB: 'kind' may be a coercion kind; cf, 'GHC.Tc.Utils.TcMType.newMetaCoVar'     TcTyVar {   varName    = name,                 realUnique = getKey (nameUnique name),                 varType  = kind,@@ -619,7 +619,7 @@         }  tcTyVarDetails :: TyVar -> TcTyVarDetails--- See Note [TcTyVars in the typechecker] in TcType+-- See Note [TcTyVars in the typechecker] in GHC.Tc.Utils.TcType tcTyVarDetails (TcTyVar { tc_tv_details = details }) = details tcTyVarDetails (TyVar {})                            = vanillaSkolemTv tcTyVarDetails var = pprPanic "tcTyVarDetails" (ppr var <+> dcolon <+> pprKind (tyVarKind var))
compiler/GHC/Types/Var.hs-boot view
@@ -1,12 +1,12 @@ module GHC.Types.Var where -import GhcPrelude ()+import GHC.Prelude ()   -- We compile this module with -XNoImplicitPrelude (for some   -- reason), so if there are no imports it does not seem to   -- depend on anything.  But it does! We must, for example,   -- compile GHC.Types in the ghc-prim library first.   -- So this otherwise-unnecessary import tells the build system-  -- that this module depends on GhcPrelude, which ensures+  -- that this module depends on GHC.Prelude, which ensures   -- that GHC.Type is built first.  data ArgFlag
compiler/GHC/Types/Var/Env.hs view
@@ -74,7 +74,7 @@         emptyTidyEnv, mkEmptyTidyEnv, delTidyEnvList     ) where -import GhcPrelude+import GHC.Prelude import qualified Data.IntMap.Strict as IntMap -- TODO: Move this to UniqFM  import GHC.Types.Name.Occurrence@@ -85,9 +85,9 @@ import GHC.Types.Unique.FM import GHC.Types.Unique.DFM import GHC.Types.Unique-import Util-import Maybes-import Outputable+import GHC.Utils.Misc+import GHC.Data.Maybe+import GHC.Utils.Outputable  {- ************************************************************************
compiler/GHC/Types/Var/Set.hs view
@@ -46,7 +46,7 @@  #include "HsVersions.h" -import GhcPrelude+import GHC.Prelude  import GHC.Types.Var      ( Var, TyVar, CoVar, TyCoVar, Id ) import GHC.Types.Unique@@ -55,7 +55,7 @@ import GHC.Types.Unique.DSet import GHC.Types.Unique.FM( disjointUFM, pluralUFM, pprUFM ) import GHC.Types.Unique.DFM( disjointUDFM, udfmToUfm, anyUDFM, allUDFM )-import Outputable (SDoc)+import GHC.Utils.Outputable (SDoc)  -- | A non-deterministic Variable Set --
+ compiler/GHC/Unit.hs view
@@ -0,0 +1,257 @@+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DeriveFunctor #-}++-- | Units are library components from Cabal packages compiled and installed in+-- a database+module GHC.Unit+   ( module GHC.Unit.Types+   , module GHC.Unit.Info+   , module GHC.Unit.Parser+   , module GHC.Unit.State+   , module GHC.Unit.Subst+   , module GHC.Unit.Module+   )+where++import GHC.Unit.Types+import GHC.Unit.Info+import GHC.Unit.Parser+import GHC.Unit.State+import GHC.Unit.Subst+import GHC.Unit.Module++-- Note [About Units]+-- ~~~~~~~~~~~~~~~~~~+--+-- Haskell users are used to manipulate Cabal packages. These packages are+-- identified by:+--    - a package name :: String+--    - a package version :: Version+--    - (a revision number, when they are registered on Hackage)+--+-- Cabal packages may contain several components (libraries, programs,+-- testsuites). In GHC we are mostly interested in libraries because those are+-- the components that can be depended upon by other components. Components in a+-- package are identified by their component name. Historically only one library+-- component was allowed per package, hence it didn't need a name. For this+-- reason, component name may be empty for one library component in each+-- package:+--    - a component name :: Maybe String+--+-- UnitId+-- ------+--+-- Cabal libraries can be compiled in various ways (different compiler options+-- or Cabal flags, different dependencies, etc.), hence using package name,+-- package version and component name isn't enough to identify a built library.+-- We use another identifier called UnitId:+--+--   package name             \+--   package version          |                       ________+--   component name           | hash of all this ==> | UnitId |+--   Cabal flags              |                       --------+--   compiler options         |+--   dependencies' UnitId     /+--+-- Fortunately GHC doesn't have to generate these UnitId: they are provided by+-- external build tools (e.g. Cabal) with `-this-unit-id` command-line parameter.+--+-- UnitIds are important because they are used to generate internal names+-- (symbols, etc.).+--+-- Wired-in units+-- --------------+--+-- Certain libraries are known to the compiler, in that we know about certain+-- entities that reside in these libraries. The compiler needs to declare static+-- Modules and Names that refer to units built from these libraries.+--+-- Hence UnitIds of wired-in libraries are fixed. Instead of letting Cabal chose+-- the UnitId for these libraries, their .cabal file uses the following stanza to+-- force it to a specific value:+--+--    ghc-options: -this-unit-id ghc-prim    -- taken from ghc-prim.cabal+--+-- The RTS also uses entities of wired-in units by directly referring to symbols+-- such as "base_GHCziIOziException_heapOverflow_closure" where the prefix is+-- the UnitId of "base" unit.+--+-- Unit databases+-- --------------+--+-- Units are stored in databases in order to be reused by other codes:+--+--    UnitKey ---> UnitInfo { exposed modules, package name, package version+--                            component name, various file paths,+--                            dependencies :: [UnitKey], etc. }+--+-- Because of the wired-in units described above, we can't exactly use UnitIds+-- as UnitKeys in the database: if we did this, we could only have a single unit+-- (compiled library) in the database for each wired-in library. As we want to+-- support databases containing several different units for the same wired-in+-- library, we do this:+--+--    * for non wired-in units:+--       * UnitId = UnitKey = Identifier (hash) computed by Cabal+--+--    * for wired-in units:+--       * UnitKey = Identifier computed by Cabal (just like for non wired-in units)+--       * UnitId  = unit-id specified with -this-unit-id command-line flag+--+-- We can expose several units to GHC via the `package-id <UnitKey>`+-- command-line parameter. We must use the UnitKeys of the units so that GHC can+-- find them in the database.+--+-- GHC then replaces the UnitKeys with UnitIds by taking into account wired-in+-- units: these units are detected thanks to their UnitInfo (especially their+-- package name).+--+-- For example, knowing that "base", "ghc-prim" and "rts" are wired-in packages,+-- the following dependency graph expressed with UnitKeys (as found in the+-- database) will be transformed into a similar graph expressed with UnitIds+-- (that are what matters for compilation):+--+--    UnitKeys+--    ~~~~~~~~                             ---> rts-1.0-hashABC <--+--                                         |                      |+--                                         |                      |+--    foo-2.0-hash123 --> base-4.1-hashXYZ ---> ghc-prim-0.5.3-hashABC+--+--    UnitIds+--    ~~~~~~~                              ---> rts <--+--                                         |          |+--                                         |          |+--    foo-2.0-hash123 --> base ---------------> ghc-prim+--+--+-- Module signatures / indefinite units / instantiated units+-- ---------------------------------------------------------+--+-- GHC distinguishes two kinds of units:+--+--    * definite: units for which every module has an associated code object+--    (i.e. real compiled code in a .o/.a/.so/.dll/...)+--+--    * indefinite: units for which some modules are replaced by module+--    signatures.+--+-- Module signatures are a kind of interface (similar to .hs-boot files). They+-- are used in place of some real code. GHC allows real modules from other+-- units to be used to fill these module holes. The process is called+-- "unit/module instantiation".+--+-- You can think of this as polymorphism at the module level: module signatures+-- give constraints on the "type" of module that can be used to fill the hole+-- (where "type" means types of the exported module entitites, etc.).+--+-- Module signatures contain enough information (datatypes, abstract types, type+-- synonyms, classes, etc.) to typecheck modules depending on them but not+-- enough to compile them. As such, indefinite units found in databases only+-- provide module interfaces (the .hi ones this time), not object code.+--+-- To distinguish between indefinite and finite unit ids at the type level, we+-- respectively use 'IndefUnitId' and 'DefUnitId' datatypes that are basically+-- wrappers over 'UnitId'.+--+-- Unit instantiation+-- ------------------+--+-- Indefinite units can be instantiated with modules from other units. The+-- instantiating units can also be instantiated themselves (if there are+-- indefinite) and so on. The 'Unit' datatype represents a unit which may have+-- been instantiated:+--+--    data Unit = RealUnit DefUnitId+--              | VirtUnit InstantiatedUnit+--+-- 'InstantiatedUnit' has two interesting fields:+--+--    * instUnitInstanceOf :: IndefUnitId+--       -- ^ the indefinite unit that is instantiated+--+--    * instUnitInsts :: [(ModuleName,(Unit,ModuleName)]+--       -- ^ a list of instantiations, where an instantiation is:+--            (module hole name, (instantiating unit, instantiating module name))+--+-- A 'Unit' may be indefinite or definite, it depends on whether some holes+-- remain in the instantiated unit OR in the instantiating units (recursively).+--+-- Pretty-printing UnitId+-- ----------------------+--+-- GHC mostly deals with UnitIds which are some opaque strings. We could display+-- them when we pretty-print a module origin, a name, etc. But it wouldn't be+-- very friendly to the user because of the hash they usually contain. E.g.+--+--    foo-4.18.1:thelib-XYZsomeUglyHashABC+--+-- Instead when we want to pretty-print a 'UnitId' we query the database to+-- get the 'UnitInfo' and print something nicer to the user:+--+--    foo-4.18.1:thelib+--+-- We do the same for wired-in units.+--+-- Currently (2020-04-06), we don't thread the database into every function that+-- pretty-prints a Name/Module/Unit. Instead querying the database is delayed+-- until the `SDoc` is transformed into a `Doc` using the database that is+-- active at this point in time. This is an issue because we want to be able to+-- unload units from the database and we also want to support several+-- independent databases loaded at the same time (see #14335). The alternatives+-- we have are:+--+--    * threading the database into every function that pretty-prints a UnitId+--    for the user (directly or indirectly).+--+--    * storing enough info to correctly display a UnitId into the UnitId+--    datatype itself. This is done in the IndefUnitId wrapper (see+--    'UnitPprInfo' datatype) but not for every 'UnitId'. Statically defined+--    'UnitId' for wired-in units would have empty UnitPprInfo so we need to+--    find some places to update them if we want to display wired-in UnitId+--    correctly. This leads to a solution similar to the first one above.+--+-- Note [VirtUnit to RealUnit improvement]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+--+-- Over the course of instantiating VirtUnits on the fly while typechecking an+-- indefinite library, we may end up with a fully instantiated VirtUnit. I.e.+-- one that could be compiled and installed in the database. During+-- type-checking we generate a virtual UnitId for it, say "abc".+--+-- Now the question is: do we have a matching installed unit in the database?+-- Suppose we have one with UnitId "xyz" (provided by Cabal so we don't know how+-- to generate it). The trouble is that if both units end up being used in the+-- same type-checking session, their names won't match (e.g. "abc:M.X" vs+-- "xyz:M.X").+--+-- As we want them to match we just replace the virtual unit with the installed+-- one: for some reason this is called "improvement".+--+-- There is one last niggle: improvement based on the package database means+-- that we might end up developing on a package that is not transitively+-- depended upon by the packages the user specified directly via command line+-- flags.  This could lead to strange and difficult to understand bugs if those+-- instantiations are out of date.  The solution is to only improve a+-- unit id if the new unit id is part of the 'preloadClosure'; i.e., the+-- closure of all the packages which were explicitly specified.++-- Note [Representation of module/name variables]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- In our ICFP'16, we use <A> to represent module holes, and {A.T} to represent+-- name holes.  This could have been represented by adding some new cases+-- to the core data types, but this would have made the existing 'moduleName'+-- and 'moduleUnit' partial, which would have required a lot of modifications+-- to existing code.+--+-- Instead, we use a fake "hole" unit:+--+--      <A>   ===> hole:A+--      {A.T} ===> hole:A.T+--+-- This encoding is quite convenient, but it is also a bit dangerous too,+-- because if you have a 'hole:A' you need to know if it's actually a+-- 'Module' or just a module stored in a 'Name'; these two cases must be+-- treated differently when doing substitutions.  'renameHoleModule'+-- and 'renameHoleUnit' assume they are NOT operating on a+-- 'Name'; 'NameShape' handles name substitutions exclusively.
+ compiler/GHC/Unit/Info.hs view
@@ -0,0 +1,179 @@+{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, MultiParamTypeClasses #-}++-- | Info about installed units (compiled libraries)+module GHC.Unit.Info+   ( GenericUnitInfo (..)+   , GenUnitInfo+   , UnitInfo+   , UnitKey (..)+   , UnitKeyInfo+   , mkUnitKeyInfo+   , mapUnitInfo+   , mkUnitPprInfo++   , mkUnit+   , expandedUnitInfoId+   , definiteUnitInfoId++   , PackageId(..)+   , PackageName(..)+   , Version(..)+   , unitPackageNameString+   , unitPackageIdString+   , pprUnitInfo+   )+where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Unit.Database+import Data.Version+import Data.Bifunctor++import GHC.Data.FastString+import GHC.Utils.Outputable+import GHC.Unit.Module as Module+import GHC.Types.Unique+import GHC.Unit.Ppr++-- | Information about an installed unit+--+-- We parameterize on the unit identifier:+--    * UnitKey: identifier used in the database (cf 'UnitKeyInfo')+--    * UnitId: identifier used to generate code (cf 'UnitInfo')+--+-- These two identifiers are different for wired-in packages. See Note [About+-- Units] in GHC.Unit+type GenUnitInfo unit = GenericUnitInfo (Indefinite unit) PackageId PackageName unit ModuleName (GenModule (GenUnit unit))++-- | A unit key in the database+newtype UnitKey = UnitKey FastString++unitKeyFS :: UnitKey -> FastString+unitKeyFS (UnitKey fs) = fs++-- | Information about an installed unit (units are identified by their database+-- UnitKey)+type UnitKeyInfo = GenUnitInfo UnitKey++-- | Information about an installed unit (units are identified by their internal+-- UnitId)+type UnitInfo    = GenUnitInfo UnitId++-- | Convert a DbUnitInfo (read from a package database) into `UnitKeyInfo`+mkUnitKeyInfo :: DbUnitInfo -> UnitKeyInfo+mkUnitKeyInfo = mapGenericUnitInfo+   mkUnitKey'+   mkIndefUnitKey'+   mkPackageIdentifier'+   mkPackageName'+   mkModuleName'+   mkModule'+   where+     mkPackageIdentifier' = PackageId      . mkFastStringByteString+     mkPackageName'       = PackageName    . mkFastStringByteString+     mkUnitKey'           = UnitKey        . mkFastStringByteString+     mkModuleName'        = mkModuleNameFS . mkFastStringByteString+     mkIndefUnitKey' cid  = Indefinite (mkUnitKey' cid) Nothing+     mkVirtUnitKey' i = case i of+      DbInstUnitId cid insts -> mkGenVirtUnit unitKeyFS (mkIndefUnitKey' cid) (fmap (bimap mkModuleName' mkModule') insts)+      DbUnitId uid           -> RealUnit (Definite (mkUnitKey' uid))+     mkModule' m = case m of+       DbModule uid n -> mkModule (mkVirtUnitKey' uid) (mkModuleName' n)+       DbModuleVar  n -> mkHoleModule (mkModuleName' n)++-- | Map over the unit parameter+mapUnitInfo :: (u -> v) -> (v -> FastString) -> GenUnitInfo u -> GenUnitInfo v+mapUnitInfo f gunitFS = mapGenericUnitInfo+   f         -- unit identifier+   (fmap f)  -- indefinite unit identifier+   id        -- package identifier+   id        -- package name+   id        -- module name+   (fmap (mapGenUnit f gunitFS)) -- instantiating modules++-- TODO: there's no need for these to be FastString, as we don't need the uniq+--       feature, but ghc doesn't currently have convenient support for any+--       other compact string types, e.g. plain ByteString or Text.++newtype PackageId   = PackageId    FastString deriving (Eq, Ord)+newtype PackageName = PackageName+   { unPackageName :: FastString+   }+   deriving (Eq, Ord)++instance Uniquable PackageId where+  getUnique (PackageId n) = getUnique n++instance Uniquable PackageName where+  getUnique (PackageName n) = getUnique n++instance Outputable PackageId where+  ppr (PackageId str) = ftext str++instance Outputable PackageName where+  ppr (PackageName str) = ftext str++unitPackageIdString :: GenUnitInfo u -> String+unitPackageIdString pkg = unpackFS str+  where+    PackageId str = unitPackageId pkg++unitPackageNameString :: GenUnitInfo u -> String+unitPackageNameString pkg = unpackFS str+  where+    PackageName str = unitPackageName pkg++pprUnitInfo :: UnitInfo -> SDoc+pprUnitInfo GenericUnitInfo {..} =+    vcat [+      field "name"                 (ppr unitPackageName),+      field "version"              (text (showVersion unitPackageVersion)),+      field "id"                   (ppr unitId),+      field "exposed"              (ppr unitIsExposed),+      field "exposed-modules"      (ppr unitExposedModules),+      field "hidden-modules"       (fsep (map ppr unitHiddenModules)),+      field "trusted"              (ppr unitIsTrusted),+      field "import-dirs"          (fsep (map text unitImportDirs)),+      field "library-dirs"         (fsep (map text unitLibraryDirs)),+      field "dynamic-library-dirs" (fsep (map text unitLibraryDynDirs)),+      field "hs-libraries"         (fsep (map text unitLibraries)),+      field "extra-libraries"      (fsep (map text unitExtDepLibsSys)),+      field "extra-ghci-libraries" (fsep (map text unitExtDepLibsGhc)),+      field "include-dirs"         (fsep (map text unitIncludeDirs)),+      field "includes"             (fsep (map text unitIncludes)),+      field "depends"              (fsep (map ppr  unitDepends)),+      field "cc-options"           (fsep (map text unitCcOptions)),+      field "ld-options"           (fsep (map text unitLinkerOptions)),+      field "framework-dirs"       (fsep (map text unitExtDepFrameworkDirs)),+      field "frameworks"           (fsep (map text unitExtDepFrameworks)),+      field "haddock-interfaces"   (fsep (map text unitHaddockInterfaces)),+      field "haddock-html"         (fsep (map text unitHaddockHTMLs))+    ]+  where+    field name body = text name <> colon <+> nest 4 body++mkUnit :: UnitInfo -> Unit+mkUnit p =+    if unitIsIndefinite p+        then mkVirtUnit (unitInstanceOf p) (unitInstantiations p)+        else RealUnit (Definite (unitId p))++expandedUnitInfoId :: UnitInfo -> Unit+expandedUnitInfoId p =+    mkVirtUnit (unitInstanceOf p) (unitInstantiations p)++definiteUnitInfoId :: UnitInfo -> Maybe DefUnitId+definiteUnitInfoId p =+    case mkUnit p of+        RealUnit def_uid -> Just def_uid+        _               -> Nothing++-- | Create a UnitPprInfo from a UnitInfo+mkUnitPprInfo :: GenUnitInfo u -> UnitPprInfo+mkUnitPprInfo i = UnitPprInfo+   (unitPackageNameString i)+   (unitPackageVersion i)+   ((unpackFS . unPackageName) <$> unitComponentName i)
+ compiler/GHC/Unit/Module.hs view
@@ -0,0 +1,151 @@+{-+(c) The University of Glasgow, 2004-2006+++Module+~~~~~~~~~~+Simply the name of a module, represented as a FastString.+These are Uniquable, hence we can build Maps with Modules as+the keys.+-}++{-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE ExplicitNamespaces #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveFunctor #-}++module GHC.Unit.Module+    ( module GHC.Unit.Types++      -- * The ModuleName type+    , module GHC.Unit.Module.Name++      -- * The ModLocation type+    , module GHC.Unit.Module.Location++      -- * ModuleEnv+    , module GHC.Unit.Module.Env+++      -- * Generalization+    , getModuleInstantiation+    , getUnitInstantiations+    , uninstantiateInstantiatedUnit+    , uninstantiateInstantiatedModule++      -- * The Module type+    , mkHoleModule+    , isHoleModule+    , stableModuleCmp+    , moduleStableString+    , moduleIsDefinite+    , HasModule(..)+    , ContainsModule(..)+    , instModuleToModule+    , unitIdEq+    , installedModuleEq+    ) where++import GHC.Prelude++import GHC.Types.Unique.DSet+import GHC.Unit.Types+import GHC.Unit.Module.Name+import GHC.Unit.Module.Location+import GHC.Unit.Module.Env+import GHC.Utils.Misc++import {-# SOURCE #-} GHC.Unit.State (PackageState)+++-- | A 'Module' is definite if it has no free holes.+moduleIsDefinite :: Module -> Bool+moduleIsDefinite = isEmptyUniqDSet . moduleFreeHoles++-- | Get a string representation of a 'Module' that's unique and stable+-- across recompilations.+-- eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"+moduleStableString :: Module -> String+moduleStableString Module{..} =+  "$" ++ unitString moduleUnit ++ "$" ++ moduleNameString moduleName+++-- | This gives a stable ordering, as opposed to the Ord instance which+-- gives an ordering based on the 'Unique's of the components, which may+-- not be stable from run to run of the compiler.+stableModuleCmp :: Module -> Module -> Ordering+stableModuleCmp (Module p1 n1) (Module p2 n2)+   = (p1 `stableUnitCmp`  p2) `thenCmp`+     (n1 `stableModuleNameCmp` n2)++class ContainsModule t where+    extractModule :: t -> Module++class HasModule m where+    getModule :: m Module+++-- | Injects an 'InstantiatedModule' to 'Module' (see also+-- 'instUnitToUnit'.+instModuleToModule :: PackageState -> InstantiatedModule -> Module+instModuleToModule pkgstate (Module iuid mod_name) =+    mkModule (instUnitToUnit pkgstate iuid) mod_name++-- | Test if a 'Module' corresponds to a given 'InstalledModule',+-- modulo instantiation.+installedModuleEq :: InstalledModule -> Module -> Bool+installedModuleEq imod mod =+    fst (getModuleInstantiation mod) == imod++-- | Test if a 'Unit' corresponds to a given 'UnitId',+-- modulo instantiation.+unitIdEq :: UnitId -> Unit -> Bool+unitIdEq iuid uid = toUnitId uid == iuid++{-+************************************************************************+*                                                                      *+                        Hole substitutions+*                                                                      *+************************************************************************+-}++-- | Given a possibly on-the-fly instantiated module, split it into+-- a 'Module' that we definitely can find on-disk, as well as an+-- instantiation if we need to instantiate it on the fly.  If the+-- instantiation is @Nothing@ no on-the-fly renaming is needed.+getModuleInstantiation :: Module -> (InstalledModule, Maybe InstantiatedModule)+getModuleInstantiation m =+    let (uid, mb_iuid) = getUnitInstantiations (moduleUnit m)+    in (Module uid (moduleName m),+        fmap (\iuid -> Module iuid (moduleName m)) mb_iuid)++-- | Return the unit-id this unit is an instance of and the module instantiations (if any).+getUnitInstantiations :: Unit -> (UnitId, Maybe InstantiatedUnit)+getUnitInstantiations (VirtUnit iuid)           = (indefUnit (instUnitInstanceOf iuid), Just iuid)+getUnitInstantiations (RealUnit (Definite uid)) = (uid, Nothing)+getUnitInstantiations HoleUnit                  = error "Hole unit"++-- | Remove instantiations of the given instantiated unit+uninstantiateInstantiatedUnit :: InstantiatedUnit -> InstantiatedUnit+uninstantiateInstantiatedUnit u =+    mkInstantiatedUnit (instUnitInstanceOf u)+                       (map (\(m,_) -> (m, mkHoleModule m))+                         (instUnitInsts u))++-- | Remove instantiations of the given module instantiated unit+uninstantiateInstantiatedModule :: InstantiatedModule -> InstantiatedModule+uninstantiateInstantiatedModule (Module uid n) = Module (uninstantiateInstantiatedUnit uid) n++-- | Test if a Module is not instantiated+isHoleModule :: GenModule (GenUnit u) -> Bool+isHoleModule (Module HoleUnit _) = True+isHoleModule _                   = False++-- | Create a hole Module+mkHoleModule :: ModuleName -> GenModule (GenUnit u)+mkHoleModule = Module HoleUnit+
+ compiler/GHC/Unit/Module/Env.hs view
@@ -0,0 +1,224 @@+-- | Module environment+module GHC.Unit.Module.Env+   ( -- * Module mappings+     ModuleEnv+   , elemModuleEnv, extendModuleEnv, extendModuleEnvList+   , extendModuleEnvList_C, plusModuleEnv_C+   , delModuleEnvList, delModuleEnv, plusModuleEnv, lookupModuleEnv+   , lookupWithDefaultModuleEnv, mapModuleEnv, mkModuleEnv, emptyModuleEnv+   , moduleEnvKeys, moduleEnvElts, moduleEnvToList+   , unitModuleEnv, isEmptyModuleEnv+   , extendModuleEnvWith, filterModuleEnv++     -- * ModuleName mappings+   , ModuleNameEnv, DModuleNameEnv++     -- * Sets of Modules+   , ModuleSet+   , emptyModuleSet, mkModuleSet, moduleSetElts+   , extendModuleSet, extendModuleSetList, delModuleSet+   , elemModuleSet, intersectModuleSet, minusModuleSet, unionModuleSet+   , unitModuleSet++     -- * InstalledModuleEnv+   , InstalledModuleEnv+   , emptyInstalledModuleEnv+   , lookupInstalledModuleEnv+   , extendInstalledModuleEnv+   , filterInstalledModuleEnv+   , delInstalledModuleEnv+   )+where++import GHC.Prelude++import GHC.Types.Unique+import GHC.Types.Unique.FM+import GHC.Types.Unique.DFM+import GHC.Unit.Types+import GHC.Utils.Misc+import Data.List (sortBy, sort)+import Data.Ord++import Data.Coerce+import Data.Map (Map)+import Data.Set (Set)+import qualified Data.Map as Map+import qualified Data.Set as Set+import qualified GHC.Data.FiniteMap as Map++-- | A map keyed off of 'Module's+newtype ModuleEnv elt = ModuleEnv (Map NDModule elt)++{-+Note [ModuleEnv performance and determinism]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+To prevent accidental reintroduction of nondeterminism the Ord instance+for Module was changed to not depend on Unique ordering and to use the+lexicographic order. This is potentially expensive, but when measured+there was no difference in performance.++To be on the safe side and not pessimize ModuleEnv uses nondeterministic+ordering on Module and normalizes by doing the lexicographic sort when+turning the env to a list.+See Note [Unique Determinism] for more information about the source of+nondeterminismand and Note [Deterministic UniqFM] for explanation of why+it matters for maps.+-}++newtype NDModule = NDModule { unNDModule :: Module }+  deriving Eq+  -- A wrapper for Module with faster nondeterministic Ord.+  -- Don't export, See [ModuleEnv performance and determinism]++instance Ord NDModule where+  compare (NDModule (Module p1 n1)) (NDModule (Module p2 n2)) =+    (getUnique p1 `nonDetCmpUnique` getUnique p2) `thenCmp`+    (getUnique n1 `nonDetCmpUnique` getUnique n2)++filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a+filterModuleEnv f (ModuleEnv e) =+  ModuleEnv (Map.filterWithKey (f . unNDModule) e)++elemModuleEnv :: Module -> ModuleEnv a -> Bool+elemModuleEnv m (ModuleEnv e) = Map.member (NDModule m) e++extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a+extendModuleEnv (ModuleEnv e) m x = ModuleEnv (Map.insert (NDModule m) x e)++extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a+                    -> ModuleEnv a+extendModuleEnvWith f (ModuleEnv e) m x =+  ModuleEnv (Map.insertWith f (NDModule m) x e)++extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a+extendModuleEnvList (ModuleEnv e) xs =+  ModuleEnv (Map.insertList [(NDModule k, v) | (k,v) <- xs] e)++extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)]+                      -> ModuleEnv a+extendModuleEnvList_C f (ModuleEnv e) xs =+  ModuleEnv (Map.insertListWith f [(NDModule k, v) | (k,v) <- xs] e)++plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a+plusModuleEnv_C f (ModuleEnv e1) (ModuleEnv e2) =+  ModuleEnv (Map.unionWith f e1 e2)++delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a+delModuleEnvList (ModuleEnv e) ms =+  ModuleEnv (Map.deleteList (map NDModule ms) e)++delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a+delModuleEnv (ModuleEnv e) m = ModuleEnv (Map.delete (NDModule m) e)++plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a+plusModuleEnv (ModuleEnv e1) (ModuleEnv e2) = ModuleEnv (Map.union e1 e2)++lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a+lookupModuleEnv (ModuleEnv e) m = Map.lookup (NDModule m) e++lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a+lookupWithDefaultModuleEnv (ModuleEnv e) x m =+  Map.findWithDefault x (NDModule m) e++mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b+mapModuleEnv f (ModuleEnv e) = ModuleEnv (Map.mapWithKey (\_ v -> f v) e)++mkModuleEnv :: [(Module, a)] -> ModuleEnv a+mkModuleEnv xs = ModuleEnv (Map.fromList [(NDModule k, v) | (k,v) <- xs])++emptyModuleEnv :: ModuleEnv a+emptyModuleEnv = ModuleEnv Map.empty++moduleEnvKeys :: ModuleEnv a -> [Module]+moduleEnvKeys (ModuleEnv e) = sort $ map unNDModule $ Map.keys e+  -- See Note [ModuleEnv performance and determinism]++moduleEnvElts :: ModuleEnv a -> [a]+moduleEnvElts e = map snd $ moduleEnvToList e+  -- See Note [ModuleEnv performance and determinism]++moduleEnvToList :: ModuleEnv a -> [(Module, a)]+moduleEnvToList (ModuleEnv e) =+  sortBy (comparing fst) [(m, v) | (NDModule m, v) <- Map.toList e]+  -- See Note [ModuleEnv performance and determinism]++unitModuleEnv :: Module -> a -> ModuleEnv a+unitModuleEnv m x = ModuleEnv (Map.singleton (NDModule m) x)++isEmptyModuleEnv :: ModuleEnv a -> Bool+isEmptyModuleEnv (ModuleEnv e) = Map.null e++-- | A set of 'Module's+type ModuleSet = Set NDModule++mkModuleSet :: [Module] -> ModuleSet+mkModuleSet = Set.fromList . coerce++extendModuleSet :: ModuleSet -> Module -> ModuleSet+extendModuleSet s m = Set.insert (NDModule m) s++extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet+extendModuleSetList s ms = foldl' (coerce . flip Set.insert) s ms++emptyModuleSet :: ModuleSet+emptyModuleSet = Set.empty++moduleSetElts :: ModuleSet -> [Module]+moduleSetElts = sort . coerce . Set.toList++elemModuleSet :: Module -> ModuleSet -> Bool+elemModuleSet = Set.member . coerce++intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet+intersectModuleSet = coerce Set.intersection++minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet+minusModuleSet = coerce Set.difference++delModuleSet :: ModuleSet -> Module -> ModuleSet+delModuleSet = coerce (flip Set.delete)++unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet+unionModuleSet = coerce Set.union++unitModuleSet :: Module -> ModuleSet+unitModuleSet = coerce Set.singleton++{-+A ModuleName has a Unique, so we can build mappings of these using+UniqFM.+-}++-- | A map keyed off of 'ModuleName's (actually, their 'Unique's)+type ModuleNameEnv elt = UniqFM elt+++-- | A map keyed off of 'ModuleName's (actually, their 'Unique's)+-- Has deterministic folds and can be deterministically converted to a list+type DModuleNameEnv elt = UniqDFM elt+++--------------------------------------------------------------------+-- InstalledModuleEnv+--------------------------------------------------------------------++-- | A map keyed off of 'InstalledModule'+newtype InstalledModuleEnv elt = InstalledModuleEnv (Map InstalledModule elt)++emptyInstalledModuleEnv :: InstalledModuleEnv a+emptyInstalledModuleEnv = InstalledModuleEnv Map.empty++lookupInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> Maybe a+lookupInstalledModuleEnv (InstalledModuleEnv e) m = Map.lookup m e++extendInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> a -> InstalledModuleEnv a+extendInstalledModuleEnv (InstalledModuleEnv e) m x = InstalledModuleEnv (Map.insert m x e)++filterInstalledModuleEnv :: (InstalledModule -> a -> Bool) -> InstalledModuleEnv a -> InstalledModuleEnv a+filterInstalledModuleEnv f (InstalledModuleEnv e) =+  InstalledModuleEnv (Map.filterWithKey f e)++delInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> InstalledModuleEnv a+delInstalledModuleEnv (InstalledModuleEnv e) m = InstalledModuleEnv (Map.delete m e)+
+ compiler/GHC/Unit/Module/Env.hs-boot view
@@ -0,0 +1,6 @@+module GHC.Unit.Module.Env where++import GhcPrelude ()+import GHC.Types.Unique.FM++type ModuleNameEnv elt = UniqFM elt
+ compiler/GHC/Unit/Module/Location.hs view
@@ -0,0 +1,78 @@+-- | Module location+module GHC.Unit.Module.Location+   ( ModLocation(..)+   , addBootSuffix+   , addBootSuffix_maybe+   , addBootSuffixLocn+   , addBootSuffixLocnOut+   )+where++import GHC.Prelude+import GHC.Utils.Outputable++-- | Module Location+--+-- Where a module lives on the file system: the actual locations+-- of the .hs, .hi and .o files, if we have them.+--+-- For a module in another package, the ml_hs_file and ml_obj_file components of+-- ModLocation are undefined.+--+-- The locations specified by a ModLocation may or may not+-- correspond to actual files yet: for example, even if the object+-- file doesn't exist, the ModLocation still contains the path to+-- where the object file will reside if/when it is created.++data ModLocation+   = ModLocation {+        ml_hs_file   :: Maybe FilePath,+                -- ^ The source file, if we have one.  Package modules+                -- probably don't have source files.++        ml_hi_file   :: FilePath,+                -- ^ Where the .hi file is, whether or not it exists+                -- yet.  Always of form foo.hi, even if there is an+                -- hi-boot file (we add the -boot suffix later)++        ml_obj_file  :: FilePath,+                -- ^ Where the .o file is, whether or not it exists yet.+                -- (might not exist either because the module hasn't+                -- been compiled yet, or because it is part of a+                -- package with a .a file)++        ml_hie_file  :: FilePath+                -- ^ Where the .hie file is, whether or not it exists+                -- yet.+  } deriving Show++instance Outputable ModLocation where+   ppr = text . show++-- | Add the @-boot@ suffix to .hs, .hi and .o files+addBootSuffix :: FilePath -> FilePath+addBootSuffix path = path ++ "-boot"++-- | Add the @-boot@ suffix if the @Bool@ argument is @True@+addBootSuffix_maybe :: Bool -> FilePath -> FilePath+addBootSuffix_maybe is_boot path+ | is_boot   = addBootSuffix path+ | otherwise = path++-- | Add the @-boot@ suffix to all file paths associated with the module+addBootSuffixLocn :: ModLocation -> ModLocation+addBootSuffixLocn locn+  = locn { ml_hs_file  = fmap addBootSuffix (ml_hs_file locn)+         , ml_hi_file  = addBootSuffix (ml_hi_file locn)+         , ml_obj_file = addBootSuffix (ml_obj_file locn)+         , ml_hie_file = addBootSuffix (ml_hie_file locn) }++-- | Add the @-boot@ suffix to all output file paths associated with the+-- module, not including the input file itself+addBootSuffixLocnOut :: ModLocation -> ModLocation+addBootSuffixLocnOut locn+  = locn { ml_hi_file  = addBootSuffix (ml_hi_file locn)+         , ml_obj_file = addBootSuffix (ml_obj_file locn)+         , ml_hie_file = addBootSuffix (ml_hie_file locn) }++
+ compiler/GHC/Unit/Module/Name.hs view
@@ -0,0 +1,98 @@++-- | The ModuleName type+module GHC.Unit.Module.Name+    ( ModuleName+    , pprModuleName+    , moduleNameFS+    , moduleNameString+    , moduleNameSlashes, moduleNameColons+    , mkModuleName+    , mkModuleNameFS+    , stableModuleNameCmp+    , parseModuleName+    )+where++import GHC.Prelude++import GHC.Utils.Outputable+import GHC.Types.Unique+import GHC.Data.FastString+import GHC.Utils.Binary+import GHC.Utils.Misc++import Control.DeepSeq+import Data.Data+import System.FilePath++import qualified Text.ParserCombinators.ReadP as Parse+import Text.ParserCombinators.ReadP (ReadP)+import Data.Char (isAlphaNum)++-- | A ModuleName is essentially a simple string, e.g. @Data.List@.+newtype ModuleName = ModuleName FastString++instance Uniquable ModuleName where+  getUnique (ModuleName nm) = getUnique nm++instance Eq ModuleName where+  nm1 == nm2 = getUnique nm1 == getUnique nm2++instance Ord ModuleName where+  nm1 `compare` nm2 = stableModuleNameCmp nm1 nm2++instance Outputable ModuleName where+  ppr = pprModuleName++instance Binary ModuleName where+  put_ bh (ModuleName fs) = put_ bh fs+  get bh = do fs <- get bh; return (ModuleName fs)++instance Data ModuleName where+  -- don't traverse?+  toConstr _   = abstractConstr "ModuleName"+  gunfold _ _  = error "gunfold"+  dataTypeOf _ = mkNoRepType "ModuleName"++instance NFData ModuleName where+  rnf x = x `seq` ()++stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering+-- ^ Compares module names lexically, rather than by their 'Unique's+stableModuleNameCmp n1 n2 = moduleNameFS n1 `compare` moduleNameFS n2++pprModuleName :: ModuleName -> SDoc+pprModuleName (ModuleName nm) =+    getPprStyle $ \ sty ->+    if codeStyle sty+        then ztext (zEncodeFS nm)+        else ftext nm++moduleNameFS :: ModuleName -> FastString+moduleNameFS (ModuleName mod) = mod++moduleNameString :: ModuleName -> String+moduleNameString (ModuleName mod) = unpackFS mod++mkModuleName :: String -> ModuleName+mkModuleName s = ModuleName (mkFastString s)++mkModuleNameFS :: FastString -> ModuleName+mkModuleNameFS s = ModuleName s++-- |Returns the string version of the module name, with dots replaced by slashes.+--+moduleNameSlashes :: ModuleName -> String+moduleNameSlashes = dots_to_slashes . moduleNameString+  where dots_to_slashes = map (\c -> if c == '.' then pathSeparator else c)++-- |Returns the string version of the module name, with dots replaced by colons.+--+moduleNameColons :: ModuleName -> String+moduleNameColons = dots_to_colons . moduleNameString+  where dots_to_colons = map (\c -> if c == '.' then ':' else c)++parseModuleName :: ReadP ModuleName+parseModuleName = fmap mkModuleName+                $ Parse.munch1 (\c -> isAlphaNum c || c `elem` "_.")+
+ compiler/GHC/Unit/Module/Name.hs-boot view
@@ -0,0 +1,6 @@+module GHC.Unit.Module.Name where++import GHC.Prelude ()++data ModuleName+
+ compiler/GHC/Unit/Parser.hs view
@@ -0,0 +1,63 @@+-- | Parsers for unit/module identifiers+module GHC.Unit.Parser+   ( parseUnit+   , parseIndefUnitId+   , parseHoleyModule+   , parseModSubst+   )+where++import GHC.Prelude++import GHC.Unit.Types+import GHC.Unit.Module.Name+import GHC.Data.FastString++import qualified Text.ParserCombinators.ReadP as Parse+import Text.ParserCombinators.ReadP (ReadP, (<++))+import Data.Char (isAlphaNum)++parseUnit :: ReadP Unit+parseUnit = parseVirtUnitId <++ parseDefUnitId+  where+    parseVirtUnitId = do+        uid   <- parseIndefUnitId+        insts <- parseModSubst+        return (mkVirtUnit uid insts)+    parseDefUnitId = do+        s <- parseUnitId+        return (RealUnit (Definite s))++parseUnitId :: ReadP UnitId+parseUnitId = do+   s <- Parse.munch1 (\c -> isAlphaNum c || c `elem` "-_.+")+   return (UnitId (mkFastString s))++parseIndefUnitId :: ReadP IndefUnitId+parseIndefUnitId = do+   uid <- parseUnitId+   return (Indefinite uid Nothing)++parseHoleyModule :: ReadP Module+parseHoleyModule = parseModuleVar <++ parseModule+    where+      parseModuleVar = do+        _ <- Parse.char '<'+        modname <- parseModuleName+        _ <- Parse.char '>'+        return (Module HoleUnit modname)+      parseModule = do+        uid <- parseUnit+        _ <- Parse.char ':'+        modname <- parseModuleName+        return (Module uid modname)++parseModSubst :: ReadP [(ModuleName, Module)]+parseModSubst = Parse.between (Parse.char '[') (Parse.char ']')+      . flip Parse.sepBy (Parse.char ',')+      $ do k <- parseModuleName+           _ <- Parse.char '='+           v <- parseHoleyModule+           return (k, v)++
+ compiler/GHC/Unit/Ppr.hs view
@@ -0,0 +1,31 @@+-- | Unit identifier pretty-printing+module GHC.Unit.Ppr+   ( UnitPprInfo (..)+   )+where++import GHC.Prelude+import GHC.Utils.Outputable+import Data.Version++-- | Subset of UnitInfo: just enough to pretty-print a unit-id+--+-- Instead of printing the unit-id which may contain a hash, we print:+--    package-version:componentname+--+data UnitPprInfo = UnitPprInfo+   { unitPprPackageName    :: String       -- ^ Source package name+   , unitPprPackageVersion :: Version      -- ^ Source package version+   , unitPprComponentName  :: Maybe String -- ^ Component name+   }++instance Outputable UnitPprInfo where+  ppr pprinfo = text $ mconcat+      [ unitPprPackageName pprinfo+      , case unitPprPackageVersion pprinfo of+         Version [] [] -> ""+         version       -> "-" ++ showVersion version+      , case unitPprComponentName pprinfo of+         Nothing    -> ""+         Just cname -> ":" ++ cname+      ]
+ compiler/GHC/Unit/State.hs view
@@ -0,0 +1,2175 @@+-- (c) The University of Glasgow, 2006++{-# LANGUAGE CPP, ScopedTypeVariables, BangPatterns, FlexibleContexts #-}++-- | Package manipulation+module GHC.Unit.State (+        module GHC.Unit.Info,++        -- * Reading the package config, and processing cmdline args+        PackageState(..),+        PackageDatabase (..),+        UnitInfoMap,+        emptyPackageState,+        initPackages,+        readPackageDatabases,+        readPackageDatabase,+        getPackageConfRefs,+        resolvePackageDatabase,+        listUnitInfoMap,++        -- * Querying the package config+        lookupUnit,+        lookupUnit',+        lookupInstalledPackage,+        lookupPackageName,+        improveUnit,+        searchPackageId,+        unsafeGetUnitInfo,+        getInstalledPackageDetails,+        displayUnitId,+        listVisibleModuleNames,+        lookupModuleInAllPackages,+        lookupModuleWithSuggestions,+        lookupPluginModuleWithSuggestions,+        LookupResult(..),+        ModuleSuggestion(..),+        ModuleOrigin(..),+        UnusablePackageReason(..),+        pprReason,++        -- * Inspecting the set of packages in scope+        getPackageIncludePath,+        getPackageLibraryPath,+        getPackageLinkOpts,+        getPackageExtraCcOpts,+        getPackageFrameworkPath,+        getPackageFrameworks,+        getPreloadPackagesAnd,++        collectArchives,+        collectIncludeDirs, collectLibraryPaths, collectLinkOpts,+        packageHsLibs, getLibs,++        -- * Utils+        mkIndefUnitId,+        updateIndefUnitId,+        unwireUnit,+        pprFlag,+        pprPackages,+        pprPackagesSimple,+        pprModuleMap,+        isIndefinite,+        isDynLinkName+    )+where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Unit.Database+import GHC.Unit.Info+import GHC.Unit.Types+import GHC.Unit.Module+import GHC.Unit.Subst+import GHC.Driver.Session+import GHC.Driver.Ways+import GHC.Types.Name       ( Name, nameModule_maybe )+import GHC.Types.Unique.FM+import GHC.Types.Unique.DFM+import GHC.Types.Unique.Set+import GHC.Utils.Misc+import GHC.Utils.Panic+import GHC.Platform+import GHC.Utils.Outputable as Outputable+import GHC.Data.Maybe++import System.Environment ( getEnv )+import GHC.Data.FastString+import GHC.Utils.Error  ( debugTraceMsg, MsgDoc, dumpIfSet_dyn,+                          withTiming, DumpFormat (..) )+import GHC.Utils.Exception++import System.Directory+import System.FilePath as FilePath+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++-- ---------------------------------------------------------------------------+-- 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 . mkUnit) res)]) +++        (if null rhs+            then []+            else [text "hidden reexport by" <+>+                    sep (map (ppr . mkUnit) 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++-- | Map from 'UnitId' to 'UnitInfo', plus+-- the transitive closure of preload units.+data UnitInfoMap = UnitInfoMap+   { unUnitInfoMap :: UniqDFM UnitInfo+      -- ^ Map from 'UnitId' to 'UnitInfo'++   , preloadClosure :: UniqSet UnitId+     -- ^ The set of transitively reachable units according+     -- to the explicitly provided command line arguments.+     -- A fully instantiated VirtUnit may only be replaced by a RealUnit from+     -- this set.+     -- See Note [VirtUnit to RealUnit improvement]+   }++-- | 'UniqFM' map from 'Unit' to a 'UnitVisibility'.+type VisibilityMap = Map Unit UnitVisibility++-- | 'UnitVisibility' records the various aspects of visibility of a particular+-- 'Unit'.+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 associated with the 'Unit'.  This is used+      -- to implement legacy behavior where @-package foo-0.1@ implicitly+      -- hides any packages named @foo@+    , uv_requirements :: Map ModuleName (Set InstantiatedModule)+      -- ^ 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 = UnitId++-- | 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 'Unit' 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 'IndefUnitId'.  This is used when+  -- users refer to packages in Backpack includes.+  packageNameMap            :: Map PackageName IndefUnitId,++  -- | 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      :: [Unit],++  -- | 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 [InstantiatedModule]+  }++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 unit = PackageDatabase+   { packageDatabasePath  :: FilePath+   , packageDatabaseUnits :: [GenUnitInfo unit]+   }++type InstalledPackageIndex = Map UnitId 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 -> Unit -> 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 -> Unit -> Maybe UnitInfo+lookupUnit' False (UnitInfoMap pkg_map _) uid  = lookupUDFM pkg_map uid+lookupUnit' True m@(UnitInfoMap pkg_map _) uid = case uid of+   HoleUnit   -> error "Hole unit"+   RealUnit _ -> lookupUDFM pkg_map uid+   VirtUnit i -> fmap (renamePackage m (instUnitInsts i))+                      (lookupUDFM pkg_map (instUnitInstanceOf i))++{-+-- | Find the indefinite package for a given 'IndefUnitId'.+-- 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.+lookupIndefUnitId :: PackageState -> IndefUnitId -> Maybe UnitInfo+lookupIndefUnitId pkgstate (IndefUnitId cid_fs) = lookupUDFM pkg_map cid_fs+  where+    UnitInfoMap pkg_map = unitInfoMap pkgstate+-}++-- | 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 :: PackageState -> PackageName -> Maybe IndefUnitId+lookupPackageName pkgstate n = Map.lookup n (packageNameMap pkgstate)++-- | Search for packages with a given package ID (e.g. \"foo-0.1\")+searchPackageId :: PackageState -> PackageId -> [UnitInfo]+searchPackageId pkgstate pid = filter ((pid ==) . unitPackageId)+                               (listUnitInfoMap pkgstate)++-- | 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 mkUnit, so that+    -- 'improveUnit' can find it.+  where add pkg_map p = addToUDFM (addToUDFM pkg_map (expandedUnitInfoId p) p)+                                  (unitId p) p++-- | Looks up the package with the given id in the package state, panicing if it is+-- not found+unsafeGetUnitInfo :: HasDebugCallStack => DynFlags -> Unit -> UnitInfo+unsafeGetUnitInfo dflags pid =+    case lookupUnit dflags pid of+      Just config -> config+      Nothing -> pprPanic "unsafeGetUnitInfo" (ppr pid)++lookupInstalledPackage :: PackageState -> UnitId -> Maybe UnitInfo+lookupInstalledPackage pkgstate uid = lookupInstalledPackage' (unitInfoMap pkgstate) uid++lookupInstalledPackage' :: UnitInfoMap -> UnitId -> Maybe UnitInfo+lookupInstalledPackage' (UnitInfoMap db _) uid = lookupUDFM db uid++getInstalledPackageDetails :: HasDebugCallStack => PackageState -> UnitId -> UnitInfo+getInstalledPackageDetails pkgstate uid =+    case lookupInstalledPackage pkgstate 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 :: PackageState -> [UnitInfo]+listUnitInfoMap pkgstate = eltsUDFM pkg_map+  where+    UnitInfoMap pkg_map _ = unitInfoMap pkgstate++-- ----------------------------------------------------------------------------+-- 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 UnitId]+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 UnitId)+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 . mapUnitInfo (\(UnitKey x) -> UnitId x) unitIdFS . mkUnitKeyInfo)+                         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{ unitIsTrusted = False }++mungeUnitInfo :: FilePath -> FilePath+                   -> UnitInfo -> UnitInfo+mungeUnitInfo top_dir pkgroot =+    mungeDynLibFields+  . mungeUnitInfoPaths top_dir pkgroot++mungeDynLibFields :: UnitInfo -> UnitInfo+mungeDynLibFields pkg =+    pkg {+      unitLibraryDynDirs = case unitLibraryDynDirs pkg of+         [] -> unitLibraryDirs pkg+         ds -> ds+    }++-- -----------------------------------------------------------------------------+-- 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 {unitIsTrusted=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 (unitIsDefinite (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 uid of+             HoleUnit       -> Map.empty+             RealUnit {}    -> Map.empty -- definite units don't have holes+             VirtUnit indef ->+                  let local = [ Map.singleton+                                  (moduleName mod)+                                  (Set.singleton $ Module indef mod_name)+                              | (mod_name, mod) <- instUnitInsts indef+                              , isHoleModule mod ]+                      recurse = [ collectHoles (moduleUnit mod)+                                | (_, mod) <- instUnitInsts indef ]+                  in Map.unionsWith Set.union $ local ++ recurse++           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 (mkUnit 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 == mkUnit 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 mkUnit 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 == unitPackageIdString p || str == unitPackageNameString p+          then Just p+          else Nothing+    finder (UnitIdArg uid) p+      = case uid of+          RealUnit (Definite iuid)+            | iuid == unitId p+            -> Just p+          VirtUnit inst+            | indefUnit (instUnitInstanceOf inst) == unitId p+            -> Just (renamePackage pkg_db (instUnitInsts inst) p)+          _ -> 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)) (unitInstantiations conf)+    in conf {+        unitInstantiations = new_insts,+        unitExposedModules = map (\(mod_name, mb_mod) -> (mod_name, fmap smod mb_mod))+                             (unitExposedModules 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 == unitPackageIdString p+        || str == unitPackageNameString p++matchingId :: UnitId -> UnitInfo -> Bool+matchingId uid p = uid == unitId p++matching :: PackageArg -> UnitInfo -> Bool+matching (PackageArg str) = matchingStr str+matching (UnitIdArg (RealUnit (Definite 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 @GHC.Builtin.Names@ 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 unitPackageVersion 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 = unitPackageNameString p `elem`+          ["integer-simple", "integer-gmp"]+        differentIntegerPkgs p p' =+          isIntegerPkg p && isIntegerPkg p' &&+          (unitPackageName p /= unitPackageName 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 units+--+-- See Note [Wired-in units] in GHC.Unit.Module++type WiredInUnitId = String+type WiredPackagesMap = Map WiredUnitId WiredUnitId++wired_in_unitids :: [WiredInUnitId]+wired_in_unitids = map unitString 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 units] in GHC.Unit.Module+  let+        matches :: UnitInfo -> WiredInUnitId -> Bool+        pc `matches` pid+            -- See Note [The integer library] in GHC.Builtin.Names+            | pid == unitString integerUnitId+            = unitPackageNameString pc `elem` ["integer-gmp", "integer-simple"]+        pc `matches` pid = unitPackageNameString 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 (mkUnit 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+        pkgstate = pkgState dflags++        -- 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, Definite (stringToUnitId 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 = unitIdFS (unDefinite wiredInUnitId)+                    in pkg {+                      unitId = UnitId fs,+                      unitInstanceOf = mkIndefUnitId pkgstate fs+                    }+                  | otherwise+                  = pkg+                upd_deps pkg = pkg {+                      -- temporary harmless DefUnitId invariant violation+                      unitDepends = map (unDefinite . upd_wired_in wiredInMap . Definite) (unitDepends pkg),+                      unitExposedModules+                        = map (\(k,v) -> (k, fmap (upd_wired_in_mod wiredInMap) v))+                              (unitExposedModules pkg)+                    }+++  return (updateWiredInDependencies pkgs, wiredInMap)++-- Helper functions for rewiring Module and Unit.  These+-- rewrite Units of modules in wired-in packages to the form known to the+-- compiler, as described in Note [Wired-in units] in GHC.Unit.Module.+--+-- For instance, base-4.9.0.0 will be rewritten to just base, to match+-- what appears in GHC.Builtin.Names.++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 -> Unit -> Unit+upd_wired_in_uid wiredInMap u = case u of+   HoleUnit           -> HoleUnit+   RealUnit def_uid   -> RealUnit (upd_wired_in wiredInMap def_uid)+   VirtUnit indef_uid ->+      VirtUnit $ mkInstantiatedUnit+        (instUnitInstanceOf indef_uid)+        (map (\(x,y) -> (x,upd_wired_in_mod wiredInMap y)) (instUnitInsts 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 (RealUnit from) vis_map of+                    Nothing -> vm+                    Just r -> Map.insert (RealUnit to) r+                                (Map.delete (RealUnit 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   [UnitId]+    -- | This package transitively depends on a package involved in a cycle.+    -- Note that the list of 'UnitId' 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   [UnitId]+    -- | This package transitively depends on a package which was ignored.+  | IgnoredDependencies  [UnitId]+    -- | This package transitively depends on a package which was+    -- shadowed by an ABI-incompatible package.+  | ShadowedDependencies [UnitId]++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 UnitId+                            (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 'UnitId' to+-- the 'UnitId's which have a dependency on it.+type RevIndex = Map UnitId [UnitId]++-- | 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 (unitDepends pkg)+    go' from r to = Map.insertWith (++) to [from] r++-- | Given a list of 'UnitId'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 :: [UnitId] -> 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+                 -> [UnitId]+depsNotAvailable pkg_map pkg = filter (not . (`Map.member` pkg_map)) (unitDepends pkg)++-- | Given a 'UnitInfo' from some 'InstalledPackageIndex'+-- return all entries in 'unitAbiDepends' which correspond to packages+-- that do not exist, OR have mismatching ABIs.+depsAbiMismatch :: InstalledPackageIndex+                -> UnitInfo+                -> [UnitId]+depsAbiMismatch pkg_map pkg = map fst . filter (not . abiMatch) $ unitAbiDepends pkg+  where+    abiMatch (dep_uid, abi)+        | Just dep_pkg <- Map.lookup dep_uid pkg_map+        = unitAbiHash 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 UnitId 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 UnitId]+               -> 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 UnitId+      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, unitDepends 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 UnitId]+    -> [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 unitIsExposed p && unitIsDefinite (mkUnit p) && mostPreferable p+                               then Map.insert (mkUnit 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 (unitPackageName p) (unitInstanceOf 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 toUnitId 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 'Unit', "unwire" it into the 'Unit'+-- that it was recorded as in the package database.+unwireUnit :: DynFlags -> Unit-> Unit+unwireUnit dflags uid@(RealUnit def_uid) =+    maybe uid RealUnit (Map.lookup def_uid (unwireMap (pkgState dflags)))+unwireUnit _ 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+                  [ (mkUnit pkg, mempty)+                  | pkg <- eltsUDFM (unUnitInfoMap pkg_db)+                  -- Exclude specific instantiations of an indefinite+                  -- package+                  , unitIsIndefinite pkg || null (unitInstantiations 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 = mkUnit pkg+    unit_lookup uid = lookupUnit' (isIndefinite dflags) pkg_db uid+                        `orElse` pprPanic "unit_lookup" (ppr uid)++    exposed_mods = unitExposedModules pkg+    hidden_mods  = unitHiddenModules 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 = mkUnit 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 = unitExposedModules pkg+            hidden_mods  = unitHiddenModules 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 :: Unit -> 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 unitIncludeDirs 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" ++) . unitExtDepLibsSys) ps,+        concatMap unitLinkerOptions 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 ++ unitExtDepLibsSys 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) (unitLibraries p)+  where+        ways0 = ways dflags++        ways1 = Set.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 `Set.member` ways1 || WayProf `Set.member` ways1+              = Set.filter (/= WayEventLog) ways1+              | otherwise+              = ways1++        tag     = waysTag (Set.filter (not . wayRTSOnly) ways2)+        rts_tag = waysTag ways2++        mkDynName x+         | WayDyn `Set.notMember` 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 'unitLibraryDirs' or 'unitLibraryDynDirs' as appropriate for the way.+libraryDirsForWay :: DynFlags -> UnitInfo -> [String]+libraryDirsForWay dflags+  | WayDyn `elem` ways dflags = unitLibraryDynDirs+  | otherwise                 = unitLibraryDirs++-- | 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 unitCcOptions 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 unitExtDepFrameworkDirs 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 unitExtDepFrameworks 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+                                                         (moduleUnit 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 . moduleUnit++    -- 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 (toUnitId . moduleUnit . 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 state) 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+          -> [(UnitId, Maybe UnitId)]+          -> IO [UnitId]+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+             -> [(UnitId,Maybe UnitId)]+             -> MaybeErr MsgDoc [UnitId]+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 (unitDepends 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 UnitId -> SDoc+missingDependencyMsg Nothing = Outputable.empty+missingDependencyMsg (Just parent)+  = space <> parens (text "dependency of" <+> ftext (unitIdFS parent))++-- -----------------------------------------------------------------------------++-- Cabal packages may contain several components (programs, libraries, etc.).+-- As far as GHC is concerned, installed package components ("units") are+-- identified by an opaque IndefUnitId string provided by Cabal. As the string+-- contains a hash, we don't want to display it to users so GHC queries the+-- database to retrieve some infos about the original source package (name,+-- version, component name).+--+-- Instead we want to display: packagename-version[:componentname]+--+-- Component name is only displayed if it isn't the default library+--+-- To do this we need to query the database (cached in DynFlags). We cache+-- these details in the IndefUnitId itself because we don't want to query+-- DynFlags each time we pretty-print the IndefUnitId+--+mkIndefUnitId :: PackageState -> FastString -> IndefUnitId+mkIndefUnitId pkgstate raw =+    let uid = UnitId raw+    in case lookupInstalledPackage pkgstate uid of+         Nothing -> Indefinite uid Nothing -- we didn't find the unit at all+         Just c  -> Indefinite uid $ Just $ mkUnitPprInfo c++-- | Update component ID details from the database+updateIndefUnitId :: PackageState -> IndefUnitId -> IndefUnitId+updateIndefUnitId pkgstate uid = mkIndefUnitId pkgstate (unitIdFS (indefUnit uid))+++displayUnitId :: PackageState -> UnitId -> Maybe String+displayUnitId pkgstate uid =+    fmap unitPackageIdString (lookupInstalledPackage pkgstate uid)++-- | Will the 'Name' come from a dynamically linked package?+isDynLinkName :: Platform -> Module -> Name -> Bool+isDynLinkName platform this_mod name+  | 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.+    --+    -- 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 platform 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 -> moduleUnit mod /= moduleUnit 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 :: PackageState -> SDoc+pprPackages = pprPackagesWith pprUnitInfo++pprPackagesWith :: (UnitInfo -> SDoc) -> PackageState -> SDoc+pprPackagesWith pprIPI pkgstate =+    vcat (intersperse (text "---") (map pprIPI (listUnitInfoMap pkgstate)))++-- | 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 :: PackageState -> SDoc+pprPackagesSimple = pprPackagesWith pprIPI+    where pprIPI ipi = let i = unitIdFS (unitId ipi)+                           e = if unitIsExposed ipi then text "E" else text " "+                           t = if unitIsTrusted 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 (moduleUnit m') <+> parens (ppr o)+        | otherwise = ppr m' <+> parens (ppr o)++fsPackageName :: UnitInfo -> FastString+fsPackageName info = fs+   where+      PackageName fs = unitPackageName info++-- | Given a fully instantiated 'InstantiatedUnit', improve it into a+-- 'RealUnit' if we can find it in the package database.+improveUnit :: UnitInfoMap -> Unit -> Unit+improveUnit _ uid@(RealUnit _) = uid -- short circuit+improveUnit 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 [VirtUnit to RealUnit improvement]+            if unitId pkg `elementOfUniqSet` preloadClosure pkg_map+                then mkUnit pkg+                else uid
+ compiler/GHC/Unit/State.hs-boot view
@@ -0,0 +1,13 @@+module GHC.Unit.State where+import GHC.Prelude+import GHC.Data.FastString+import {-# SOURCE #-} GHC.Unit.Types (IndefUnitId, Unit, UnitId)+data PackageState+data UnitInfoMap+data PackageDatabase unit+emptyPackageState :: PackageState+mkIndefUnitId :: PackageState -> FastString -> IndefUnitId+displayUnitId :: PackageState -> UnitId -> Maybe String+improveUnit :: UnitInfoMap -> Unit -> Unit+unitInfoMap :: PackageState -> UnitInfoMap+updateIndefUnitId :: PackageState -> IndefUnitId -> IndefUnitId
+ compiler/GHC/Unit/Subst.hs view
@@ -0,0 +1,69 @@+-- | Module hole substitutions+module GHC.Unit.Subst+   ( ShHoleSubst+   , renameHoleUnit+   , renameHoleModule+   , renameHoleUnit'+   , renameHoleModule'+   )+where++import GHC.Prelude++import {-# SOURCE #-} GHC.Unit.State+import GHC.Unit.Types+import GHC.Unit.Module.Env+import GHC.Unit.Module+import GHC.Types.Unique.FM+import GHC.Types.Unique.DFM+import GHC.Types.Unique.DSet++-- | Substitution on module variables, mapping module names to module+-- identifiers.+type ShHoleSubst = ModuleNameEnv Module++-- | Substitutes holes in a 'Module'.  NOT suitable for being called+-- directly on a 'nameModule', see Note [Representation of module/name variable].+-- @p[A=<A>]:B@ maps to @p[A=q():A]:B@ with @A=q():A@;+-- similarly, @<A>@ maps to @q():A@.+renameHoleModule :: PackageState -> ShHoleSubst -> Module -> Module+renameHoleModule state = renameHoleModule' (unitInfoMap state)++-- | Substitutes holes in a 'Unit', suitable for renaming when+-- an include occurs; see Note [Representation of module/name variable].+--+-- @p[A=<A>]@ maps to @p[A=<B>]@ with @A=<B>@.+renameHoleUnit :: PackageState -> ShHoleSubst -> Unit -> Unit+renameHoleUnit state = renameHoleUnit' (unitInfoMap state)++-- | Like 'renameHoleModule', but requires only 'UnitInfoMap'+-- so it can be used by "Packages".+renameHoleModule' :: UnitInfoMap -> ShHoleSubst -> Module -> Module+renameHoleModule' pkg_map env m+  | not (isHoleModule m) =+        let uid = renameHoleUnit' pkg_map env (moduleUnit m)+        in mkModule uid (moduleName m)+  | Just m' <- lookupUFM env (moduleName m) = m'+  -- NB m = <Blah>, that's what's in scope.+  | otherwise = m++-- | Like 'renameHoleUnit, but requires only 'UnitInfoMap'+-- so it can be used by "Packages".+renameHoleUnit' :: UnitInfoMap -> ShHoleSubst -> Unit -> Unit+renameHoleUnit' pkg_map env uid =+    case uid of+      (VirtUnit+        InstantiatedUnit{ instUnitInstanceOf = cid+                        , instUnitInsts      = insts+                        , instUnitHoles      = fh })+          -> if isNullUFM (intersectUFM_C const (udfmToUfm (getUniqDSet fh)) env)+                then uid+                -- Functorially apply the substitution to the instantiation,+                -- then check the 'UnitInfoMap' to see if there is+                -- a compiled version of this 'InstantiatedUnit' we can improve to.+                -- See Note [VirtUnit to RealUnit improvement]+                else improveUnit pkg_map $+                        mkVirtUnit cid+                            (map (\(k,v) -> (k, renameHoleModule' pkg_map env v)) insts)+      _ -> uid+
+ compiler/GHC/Unit/Types.hs view
@@ -0,0 +1,636 @@+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveFunctor #-}++-- | Unit & Module types+--+-- This module is used to resolve the loops between Unit and Module types+-- (Module references a Unit and vice-versa).+module GHC.Unit.Types+   ( -- * Modules+     GenModule (..)+   , Module+   , InstalledModule+   , InstantiatedModule+   , mkModule+   , pprModule+   , pprInstantiatedModule+   , moduleFreeHoles++     -- * Units+   , GenUnit (..)+   , Unit+   , UnitId (..)+   , GenInstantiatedUnit (..)+   , InstantiatedUnit+   , IndefUnitId+   , DefUnitId+   , Instantiations+   , GenInstantiations+   , mkGenInstantiatedUnit+   , mkInstantiatedUnit+   , mkInstantiatedUnitHash+   , mkGenVirtUnit+   , mkVirtUnit+   , mapGenUnit+   , unitFreeModuleHoles+   , fsToUnit+   , unitFS+   , unitString+   , instUnitToUnit+   , toUnitId+   , stringToUnit+   , stableUnitCmp+   , unitIsDefinite++     -- * Unit Ids+   , unitIdString+   , stringToUnitId++     -- * Utils+   , Definite (..)+   , Indefinite (..)++     -- * Wired-in units+   , primUnitId+   , integerUnitId+   , baseUnitId+   , rtsUnitId+   , thUnitId+   , mainUnitId+   , thisGhcUnitId+   , interactiveUnitId+   , isInteractiveModule+   , wiredInUnitIds+   )+where++import GHC.Prelude+import GHC.Types.Unique+import GHC.Types.Unique.DSet+import GHC.Unit.Ppr+import GHC.Unit.Module.Name+import GHC.Utils.Binary+import GHC.Utils.Outputable+import GHC.Data.FastString+import GHC.Utils.Encoding+import GHC.Utils.Fingerprint+import GHC.Utils.Misc++import Control.DeepSeq+import Data.Data+import Data.List (sortBy )+import Data.Function+import Data.Bifunctor+import qualified Data.ByteString as BS+import qualified Data.ByteString.Char8 as BS.Char8++import {-# SOURCE #-} GHC.Unit.State (improveUnit, PackageState, unitInfoMap, displayUnitId)+import {-# SOURCE #-} GHC.Driver.Session (pkgState)++---------------------------------------------------------------------+-- MODULES+---------------------------------------------------------------------++-- | A generic module is a pair of a unit identifier and a 'ModuleName'.+data GenModule unit = Module+   { moduleUnit :: !unit       -- ^ Unit the module belongs to+   , moduleName :: !ModuleName -- ^ Module name (e.g. A.B.C)+   }+   deriving (Eq,Ord,Data,Functor)++-- | A Module is a pair of a 'Unit' and a 'ModuleName'.+type Module = GenModule Unit++-- | A 'InstalledModule' is a 'Module' whose unit is identified with an+-- 'UnitId'.+type InstalledModule = GenModule UnitId++-- | An `InstantiatedModule` is a 'Module' whose unit is identified with an `InstantiatedUnit`.+type InstantiatedModule = GenModule InstantiatedUnit+++mkModule :: u -> ModuleName -> GenModule u+mkModule = Module++instance Uniquable Module where+  getUnique (Module p n) = getUnique (unitFS p `appendFS` moduleNameFS n)++instance Binary a => Binary (GenModule a) where+  put_ bh (Module p n) = put_ bh p >> put_ bh n+  get bh = do p <- get bh; n <- get bh; return (Module p n)++instance NFData (GenModule a) where+  rnf (Module unit name) = unit `seq` name `seq` ()++instance Outputable Module where+  ppr = pprModule++instance Outputable InstalledModule where+  ppr (Module p n) =+    ppr p <> char ':' <> pprModuleName n++instance Outputable InstantiatedModule where+  ppr = pprInstantiatedModule++instance Outputable InstantiatedUnit where+    ppr uid =+      -- getPprStyle $ \sty ->+      ppr cid <>+        (if not (null insts) -- pprIf+          then+            brackets (hcat+                (punctuate comma $+                    [ ppr modname <> text "=" <> pprModule m+                    | (modname, m) <- insts]))+          else empty)+     where+      cid   = instUnitInstanceOf uid+      insts = instUnitInsts uid+++pprModule :: Module -> SDoc+pprModule mod@(Module p n)  = getPprStyle doc+ where+  doc sty+    | codeStyle sty =+        (if p == mainUnitId+                then empty -- never qualify the main package in code+                else ztext (zEncodeFS (unitFS p)) <> char '_')+            <> pprModuleName n+    | qualModule sty mod =+        case p of+          HoleUnit -> angleBrackets (pprModuleName n)+          _        -> ppr (moduleUnit mod) <> char ':' <> pprModuleName n+    | otherwise =+        pprModuleName n+++pprInstantiatedModule :: InstantiatedModule -> SDoc+pprInstantiatedModule (Module uid m) =+    ppr uid <> char ':' <> ppr m++---------------------------------------------------------------------+-- UNITS+---------------------------------------------------------------------++-- | A unit identifier identifies a (possibly partially) instantiated library.+-- It is primarily used as part of 'Module', which in turn is used in 'Name',+-- which is used to give names to entities when typechecking.+--+-- There are two possible forms for a 'Unit':+--+-- 1) It can be a 'RealUnit', in which case we just have a 'DefUnitId' that+-- uniquely identifies some fully compiled, installed library we have on disk.+--+-- 2) It can be an 'VirtUnit'. When we are typechecking a library with missing+-- holes, we may need to instantiate a library on the fly (in which case we+-- don't have any on-disk representation.)  In that case, you have an+-- 'InstantiatedUnit', which explicitly records the instantiation, so that we+-- can substitute over it.+data GenUnit uid+    = RealUnit !(Definite uid)+      -- ^ Installed definite unit (either a fully instantiated unit or a closed unit)++    | VirtUnit {-# UNPACK #-} !(GenInstantiatedUnit uid)+      -- ^ Virtual unit instantiated on-the-fly. It may be definite if all the+      -- holes are instantiated but we don't have code objects for it.++    | HoleUnit+      -- ^ Fake hole unit++-- | An instantiated unit.+--+-- It identifies an indefinite library (with holes) that has been instantiated.+--+-- This unit may be indefinite or not (i.e. with remaining holes or not). If it+-- is definite, we don't know if it has already been compiled and installed in a+-- database. Nevertheless, we have a mechanism called "improvement" to try to+-- match a fully instantiated unit with existing compiled and installed units:+-- see Note [VirtUnit to RealUnit improvement].+--+-- An indefinite unit identifier pretty-prints to something like+-- @p[H=<H>,A=aimpl:A>]@ (@p@ is the 'IndefUnitId', and the+-- brackets enclose the module substitution).+data GenInstantiatedUnit unit+    = InstantiatedUnit {+        -- | A private, uniquely identifying representation of+        -- an InstantiatedUnit. This string is completely private to GHC+        -- and is just used to get a unique.+        instUnitFS :: !FastString,+        -- | Cached unique of 'unitFS'.+        instUnitKey :: !Unique,+        -- | The indefinite unit being instantiated.+        instUnitInstanceOf :: !(Indefinite unit),+        -- | The sorted (by 'ModuleName') instantiations of this unit.+        instUnitInsts :: !(GenInstantiations unit),+        -- | A cache of the free module holes of 'instUnitInsts'.+        -- This lets us efficiently tell if a 'InstantiatedUnit' has been+        -- fully instantiated (empty set of free module holes)+        -- and whether or not a substitution can have any effect.+        instUnitHoles :: UniqDSet ModuleName+    }++type Unit             = GenUnit             UnitId+type InstantiatedUnit = GenInstantiatedUnit UnitId++type GenInstantiations unit = [(ModuleName,GenModule (GenUnit unit))]+type Instantiations         = GenInstantiations UnitId++holeUnique :: Unique+holeUnique = getUnique holeFS++holeFS :: FastString+holeFS = fsLit "<hole>"+++instance Eq (GenInstantiatedUnit unit) where+  u1 == u2 = instUnitKey u1 == instUnitKey u2++instance Ord (GenInstantiatedUnit unit) where+  u1 `compare` u2 = instUnitFS u1 `compare` instUnitFS u2++instance Binary InstantiatedUnit where+  put_ bh indef = do+    put_ bh (instUnitInstanceOf indef)+    put_ bh (instUnitInsts indef)+  get bh = do+    cid   <- get bh+    insts <- get bh+    let fs = mkInstantiatedUnitHash cid insts+    return InstantiatedUnit {+            instUnitInstanceOf = cid,+            instUnitInsts = insts,+            instUnitHoles = unionManyUniqDSets (map (moduleFreeHoles.snd) insts),+            instUnitFS = fs,+            instUnitKey = getUnique fs+           }++instance Eq Unit where+  uid1 == uid2 = unitUnique uid1 == unitUnique uid2++instance Uniquable Unit where+  getUnique = unitUnique++instance Ord Unit where+  nm1 `compare` nm2 = stableUnitCmp nm1 nm2++instance Data Unit where+  -- don't traverse?+  toConstr _   = abstractConstr "Unit"+  gunfold _ _  = error "gunfold"+  dataTypeOf _ = mkNoRepType "Unit"++instance NFData Unit where+  rnf x = x `seq` ()++-- | Compares unit ids lexically, rather than by their 'Unique's+stableUnitCmp :: Unit -> Unit -> Ordering+stableUnitCmp p1 p2 = unitFS p1 `compare` unitFS p2++instance Outputable Unit where+   ppr pk = pprUnit pk++pprUnit :: Unit -> SDoc+pprUnit (RealUnit uid) = ppr uid+pprUnit (VirtUnit uid) = ppr uid+pprUnit HoleUnit       = ftext holeFS++instance Show Unit where+    show = unitString++-- Performance: would prefer to have a NameCache like thing+instance Binary Unit where+  put_ bh (RealUnit def_uid) = do+    putByte bh 0+    put_ bh def_uid+  put_ bh (VirtUnit indef_uid) = do+    putByte bh 1+    put_ bh indef_uid+  put_ bh HoleUnit = do+    putByte bh 2+  get bh = do b <- getByte bh+              case b of+                0 -> fmap RealUnit (get bh)+                1 -> fmap VirtUnit (get bh)+                _ -> pure HoleUnit++instance Binary unit => Binary (Indefinite unit) where+  put_ bh (Indefinite fs _) = put_ bh fs+  get bh = do { fs <- get bh; return (Indefinite fs Nothing) }++++-- | Retrieve the set of free module holes of a 'Unit'.+unitFreeModuleHoles :: GenUnit u -> UniqDSet ModuleName+unitFreeModuleHoles (VirtUnit x) = instUnitHoles x+unitFreeModuleHoles (RealUnit _) = emptyUniqDSet+unitFreeModuleHoles HoleUnit     = emptyUniqDSet++-- | Calculate the free holes of a 'Module'.  If this set is non-empty,+-- this module was defined in an indefinite library that had required+-- signatures.+--+-- If a module has free holes, that means that substitutions can operate on it;+-- if it has no free holes, substituting over a module has no effect.+moduleFreeHoles :: GenModule (GenUnit u) -> UniqDSet ModuleName+moduleFreeHoles (Module HoleUnit name) = unitUniqDSet name+moduleFreeHoles (Module u        _   ) = unitFreeModuleHoles u+++-- | Create a new 'GenInstantiatedUnit' given an explicit module substitution.+mkGenInstantiatedUnit :: (unit -> FastString) -> Indefinite unit -> GenInstantiations unit -> GenInstantiatedUnit unit+mkGenInstantiatedUnit gunitFS cid insts =+    InstantiatedUnit {+        instUnitInstanceOf = cid,+        instUnitInsts = sorted_insts,+        instUnitHoles = unionManyUniqDSets (map (moduleFreeHoles.snd) insts),+        instUnitFS = fs,+        instUnitKey = getUnique fs+    }+  where+     fs = mkGenInstantiatedUnitHash gunitFS cid sorted_insts+     sorted_insts = sortBy (stableModuleNameCmp `on` fst) insts++-- | Create a new 'InstantiatedUnit' given an explicit module substitution.+mkInstantiatedUnit :: IndefUnitId -> Instantiations -> InstantiatedUnit+mkInstantiatedUnit = mkGenInstantiatedUnit unitIdFS+++-- | Smart constructor for instantiated GenUnit+mkGenVirtUnit :: (unit -> FastString) -> Indefinite unit -> [(ModuleName, GenModule (GenUnit unit))] -> GenUnit unit+mkGenVirtUnit _gunitFS uid []    = RealUnit $ Definite (indefUnit uid) -- huh? indefinite unit without any instantiation/hole?+mkGenVirtUnit gunitFS  uid insts = VirtUnit $ mkGenInstantiatedUnit gunitFS uid insts++-- | Smart constructor for VirtUnit+mkVirtUnit :: IndefUnitId -> Instantiations -> Unit+mkVirtUnit = mkGenVirtUnit unitIdFS++-- | Generate a uniquely identifying hash (internal unit-id) for an instantiated+-- unit.+--+-- This is a one-way function. If the indefinite unit has not been instantiated at all, we return its unit-id.+--+-- This hash is completely internal to GHC and is not used for symbol names or+-- file paths. It is different from the hash Cabal would produce for the same+-- instantiated unit.+mkGenInstantiatedUnitHash :: (unit -> FastString) -> Indefinite unit -> [(ModuleName, GenModule (GenUnit unit))] -> FastString+mkGenInstantiatedUnitHash gunitFS cid sorted_holes =+    mkFastStringByteString+  . fingerprintUnitId (bytesFS (gunitFS (indefUnit cid)))+  $ hashInstantiations gunitFS sorted_holes++mkInstantiatedUnitHash :: IndefUnitId -> Instantiations -> FastString+mkInstantiatedUnitHash = mkGenInstantiatedUnitHash unitIdFS++-- | Generate a hash for a sorted module instantiation.+hashInstantiations :: (unit -> FastString) -> [(ModuleName, GenModule (GenUnit unit))] -> Fingerprint+hashInstantiations gunitFS sorted_holes =+    fingerprintByteString+  . BS.concat $ do+        (m, b) <- sorted_holes+        [ bytesFS (moduleNameFS m),                   BS.Char8.singleton ' ',+          bytesFS (genUnitFS gunitFS (moduleUnit b)), BS.Char8.singleton ':',+          bytesFS (moduleNameFS (moduleName b)),      BS.Char8.singleton '\n']++fingerprintUnitId :: BS.ByteString -> Fingerprint -> BS.ByteString+fingerprintUnitId prefix (Fingerprint a b)+    = BS.concat+    $ [ prefix+      , BS.Char8.singleton '-'+      , BS.Char8.pack (toBase62Padded a)+      , BS.Char8.pack (toBase62Padded b) ]++unitUnique :: Unit -> Unique+unitUnique (VirtUnit x)            = instUnitKey x+unitUnique (RealUnit (Definite x)) = getUnique x+unitUnique HoleUnit                = holeUnique++unitFS :: Unit -> FastString+unitFS = genUnitFS unitIdFS++genUnitFS :: (unit -> FastString) -> GenUnit unit -> FastString+genUnitFS _gunitFS (VirtUnit x)            = instUnitFS x+genUnitFS gunitFS  (RealUnit (Definite x)) = gunitFS x+genUnitFS _gunitFS HoleUnit                = holeFS++-- | Create a new simple unit identifier from a 'FastString'.  Internally,+-- this is primarily used to specify wired-in unit identifiers.+fsToUnit :: FastString -> Unit+fsToUnit = RealUnit . Definite . UnitId++unitString :: Unit -> String+unitString = unpackFS . unitFS++stringToUnit :: String -> Unit+stringToUnit = fsToUnit . mkFastString++-- | Map over the unit type of a 'GenUnit'+mapGenUnit :: (u -> v) -> (v -> FastString) -> GenUnit u -> GenUnit v+mapGenUnit f gunitFS = go+   where+      go gu = case gu of+               HoleUnit   -> HoleUnit+               RealUnit d -> RealUnit (fmap f d)+               VirtUnit i ->+                  VirtUnit $ mkGenInstantiatedUnit gunitFS+                     (fmap f (instUnitInstanceOf i))+                     (fmap (second (fmap go)) (instUnitInsts i))+++-- | Check the database to see if we already have an installed unit that+-- corresponds to the given 'InstantiatedUnit'.+--+-- Return a `UnitId` which either wraps the `InstantiatedUnit` unchanged or+-- references a matching installed unit.+--+-- See Note [VirtUnit to RealUnit improvement]+instUnitToUnit :: PackageState -> InstantiatedUnit -> Unit+instUnitToUnit pkgstate iuid =+    -- NB: suppose that we want to compare the indefinite+    -- unit id p[H=impl:H] against p+abcd (where p+abcd+    -- happens to be the existing, installed version of+    -- p[H=impl:H].  If we *only* wrap in p[H=impl:H]+    -- VirtUnit, they won't compare equal; only+    -- after improvement will the equality hold.+    improveUnit (unitInfoMap pkgstate) $+        VirtUnit iuid++-- | Return the UnitId of the Unit. For instantiated units, return the+-- UnitId of the indefinite unit this unit is an instance of.+toUnitId :: Unit -> UnitId+toUnitId (RealUnit (Definite iuid)) = iuid+toUnitId (VirtUnit indef)           = indefUnit (instUnitInstanceOf indef)+toUnitId HoleUnit                   = error "Hole unit"++-- | A 'Unit' is definite if it has no free holes.+unitIsDefinite :: Unit -> Bool+unitIsDefinite = isEmptyUniqDSet . unitFreeModuleHoles++---------------------------------------------------------------------+-- UNIT IDs+---------------------------------------------------------------------++-- | A UnitId identifies a built library in a database and is used to generate+-- unique symbols, etc. It's usually of the form:+--+--    pkgname-1.2:libname+hash+--+-- These UnitId are provided to us via the @-this-unit-id@ flag.+--+-- The library in question may be definite or indefinite; if it is indefinite,+-- none of the holes have been filled (we never install partially instantiated+-- libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit).  Put+-- another way, an installed unit id is either fully instantiated, or not+-- instantiated at all.+newtype UnitId =+    UnitId {+      -- | The full hashed unit identifier, including the component id+      -- and the hash.+      unitIdFS :: FastString+    }++instance Binary UnitId where+  put_ bh (UnitId fs) = put_ bh fs+  get bh = do fs <- get bh; return (UnitId fs)++instance Eq UnitId where+    uid1 == uid2 = getUnique uid1 == getUnique uid2++instance Ord UnitId where+    u1 `compare` u2 = unitIdFS u1 `compare` unitIdFS u2++instance Uniquable UnitId where+    getUnique = getUnique . unitIdFS++instance Outputable UnitId where+    ppr uid@(UnitId fs) =+        getPprStyle $ \sty ->+        sdocWithDynFlags $ \dflags ->+          case displayUnitId (pkgState dflags) uid of+            Just str | not (debugStyle sty) -> text str+            _ -> ftext fs++-- | A 'DefUnitId' is an 'UnitId' with the invariant that+-- it only refers to a definite library; i.e., one we have generated+-- code for.+type DefUnitId = Definite UnitId++unitIdString :: UnitId -> String+unitIdString = unpackFS . unitIdFS++stringToUnitId :: String -> UnitId+stringToUnitId = UnitId . mkFastString++---------------------------------------------------------------------+-- UTILS+---------------------------------------------------------------------++-- | A definite unit (i.e. without any free module hole)+newtype Definite unit = Definite { unDefinite :: unit }+    deriving (Eq, Ord, Functor)++instance Outputable unit => Outputable (Definite unit) where+    ppr (Definite uid) = ppr uid++instance Binary unit => Binary (Definite unit) where+    put_ bh (Definite uid) = put_ bh uid+    get bh = do uid <- get bh; return (Definite uid)+++-- | An 'IndefUnitId' is an 'UnitId' with the invariant that it only+-- refers to an indefinite library; i.e., one that can be instantiated.+type IndefUnitId = Indefinite UnitId++data Indefinite unit = Indefinite+   { indefUnit        :: !unit             -- ^ Unit identifier+   , indefUnitPprInfo :: Maybe UnitPprInfo -- ^ Cache for some unit info retrieved from the DB+   }+   deriving (Functor)++instance Eq unit => Eq (Indefinite unit) where+   a == b = indefUnit a == indefUnit b++instance Ord unit => Ord (Indefinite unit) where+   compare a b = compare (indefUnit a) (indefUnit b)+++instance Uniquable unit => Uniquable (Indefinite unit) where+  getUnique (Indefinite n _) = getUnique n++instance Outputable unit => Outputable (Indefinite unit) where+  ppr (Indefinite uid Nothing)        = ppr uid+  ppr (Indefinite uid (Just pprinfo)) =+    getPprStyle $ \sty ->+      if debugStyle sty+         then ppr uid+         else ppr pprinfo+++---------------------------------------------------------------------+-- WIRED-IN UNITS+---------------------------------------------------------------------++{-+Note [Wired-in units]+~~~~~~~~~~~~~~~~~~~~~++Certain packages are known to the compiler, in that we know about certain+entities that reside in these packages, and the compiler needs to+declare static Modules and Names that refer to these packages.  Hence+the wired-in packages can't include version numbers in their package UnitId,+since we don't want to bake the version numbers of these packages into GHC.++So here's the plan.  Wired-in units are still versioned as+normal in the packages database, and you can still have multiple+versions of them installed. To the user, everything looks normal.++However, for each invocation of GHC, only a single instance of each wired-in+package will be recognised (the desired one is selected via+@-package@\/@-hide-package@), and GHC will internally pretend that it has the+*unversioned* 'UnitId', including in .hi files and object file symbols.++Unselected versions of wired-in packages will be ignored, as will any other+package that depends directly or indirectly on it (much as if you+had used @-ignore-package@).++The affected packages are compiled with, e.g., @-this-unit-id base@, so that+the symbols in the object files have the unversioned unit id in their name.++Make sure you change 'GHC.Unit.State.findWiredInPackages' if you add an entry here.++For `integer-gmp`/`integer-simple` we also change the base name to+`integer-wired-in`, but this is fundamentally no different.+See Note [The integer library] in PrelNames.+-}++integerUnitId, primUnitId,+  baseUnitId, rtsUnitId,+  thUnitId, mainUnitId, thisGhcUnitId, interactiveUnitId  :: Unit+primUnitId        = fsToUnit (fsLit "ghc-prim")+integerUnitId     = fsToUnit (fsLit "integer-wired-in")+   -- See Note [The integer library] in PrelNames+baseUnitId        = fsToUnit (fsLit "base")+rtsUnitId         = fsToUnit (fsLit "rts")+thUnitId          = fsToUnit (fsLit "template-haskell")+thisGhcUnitId     = fsToUnit (fsLit "ghc")+interactiveUnitId = fsToUnit (fsLit "interactive")++-- | This is the package Id for the current program.  It is the default+-- package Id if you don't specify a package name.  We don't add this prefix+-- to symbol names, since there can be only one main package per program.+mainUnitId      = fsToUnit (fsLit "main")++isInteractiveModule :: Module -> Bool+isInteractiveModule mod = moduleUnit mod == interactiveUnitId++wiredInUnitIds :: [Unit]+wiredInUnitIds =+   [ primUnitId+   , integerUnitId+   , baseUnitId+   , rtsUnitId+   , thUnitId+   , thisGhcUnitId+   ]
+ compiler/GHC/Unit/Types.hs-boot view
@@ -0,0 +1,18 @@+module GHC.Unit.Types where++import GHC.Prelude ()+import {-# SOURCE #-} GHC.Utils.Outputable+import {-# SOURCE #-} GHC.Unit.Module.Name++data UnitId+data GenModule unit+data GenUnit uid+data Indefinite unit++type Module      = GenModule  Unit+type Unit        = GenUnit    UnitId+type IndefUnitId = Indefinite UnitId++moduleName :: GenModule a -> ModuleName+moduleUnit :: GenModule a -> a+pprModule :: Module -> SDoc
+ compiler/GHC/Utils/Binary.hs view
@@ -0,0 +1,1457 @@+{-# LANGUAGE CPP #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE MultiWayIf #-}+{-# LANGUAGE BangPatterns #-}++{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}+-- We always optimise this, otherwise performance of a non-optimised+-- compiler is severely affected++--+-- (c) The University of Glasgow 2002-2006+--+-- Binary I/O library, with special tweaks for GHC+--+-- Based on the nhc98 Binary library, which is copyright+-- (c) Malcolm Wallace and Colin Runciman, University of York, 1998.+-- Under the terms of the license for that software, we must tell you+-- where you can obtain the original version of the Binary library, namely+--     http://www.cs.york.ac.uk/fp/nhc98/++module GHC.Utils.Binary+  ( {-type-}  Bin,+    {-class-} Binary(..),+    {-type-}  BinHandle,+    SymbolTable, Dictionary,++   BinData(..), dataHandle, handleData,++   openBinMem,+--   closeBin,++   seekBin,+   tellBin,+   castBin,+   withBinBuffer,++   writeBinMem,+   readBinMem,++   putAt, getAt,++   -- * For writing instances+   putByte,+   getByte,++   -- * Variable length encodings+   putULEB128,+   getULEB128,+   putSLEB128,+   getSLEB128,++   -- * Lazy Binary I/O+   lazyGet,+   lazyPut,++   -- * User data+   UserData(..), getUserData, setUserData,+   newReadState, newWriteState,+   putDictionary, getDictionary, putFS,+  ) where++#include "HsVersions.h"++import GHC.Prelude++import {-# SOURCE #-} GHC.Types.Name (Name)+import GHC.Data.FastString+import GHC.Utils.Panic.Plain+import GHC.Types.Unique.FM+import GHC.Data.FastMutInt+import GHC.Utils.Fingerprint+import GHC.Types.Basic+import GHC.Types.SrcLoc++import Control.DeepSeq+import Foreign+import Data.Array+import Data.ByteString (ByteString)+import qualified Data.ByteString.Internal as BS+import qualified Data.ByteString.Unsafe   as BS+import Data.IORef+import Data.Char                ( ord, chr )+import Data.Time+import Data.List (unfoldr)+import Type.Reflection+import Type.Reflection.Unsafe+import Data.Kind (Type)+import GHC.Exts (TYPE, RuntimeRep(..), VecCount(..), VecElem(..))+import Control.Monad            ( when, (<$!>), unless )+import System.IO as IO+import System.IO.Unsafe         ( unsafeInterleaveIO )+import System.IO.Error          ( mkIOError, eofErrorType )+import GHC.Real                 ( Ratio(..) )+import GHC.Serialized++type BinArray = ForeignPtr Word8++++---------------------------------------------------------------+-- BinData+---------------------------------------------------------------++data BinData = BinData Int BinArray++instance NFData BinData where+  rnf (BinData sz _) = rnf sz++instance Binary BinData where+  put_ bh (BinData sz dat) = do+    put_ bh sz+    putPrim bh sz $ \dest ->+      withForeignPtr dat $ \orig ->+        copyBytes dest orig sz+  --+  get bh = do+    sz <- get bh+    dat <- mallocForeignPtrBytes sz+    getPrim bh sz $ \orig ->+      withForeignPtr dat $ \dest ->+        copyBytes dest orig sz+    return (BinData sz dat)++dataHandle :: BinData -> IO BinHandle+dataHandle (BinData size bin) = do+  ixr <- newFastMutInt+  szr <- newFastMutInt+  writeFastMutInt ixr 0+  writeFastMutInt szr size+  binr <- newIORef bin+  return (BinMem noUserData ixr szr binr)++handleData :: BinHandle -> IO BinData+handleData (BinMem _ ixr _ binr) = BinData <$> readFastMutInt ixr <*> readIORef binr++---------------------------------------------------------------+-- BinHandle+---------------------------------------------------------------++data BinHandle+  = BinMem {                     -- binary data stored in an unboxed array+     bh_usr :: UserData,         -- sigh, need parameterized modules :-)+     _off_r :: !FastMutInt,      -- the current offset+     _sz_r  :: !FastMutInt,      -- size of the array (cached)+     _arr_r :: !(IORef BinArray) -- the array (bounds: (0,size-1))+    }+        -- XXX: should really store a "high water mark" for dumping out+        -- the binary data to a file.++getUserData :: BinHandle -> UserData+getUserData bh = bh_usr bh++setUserData :: BinHandle -> UserData -> BinHandle+setUserData bh us = bh { bh_usr = us }++-- | Get access to the underlying buffer.+--+-- It is quite important that no references to the 'ByteString' leak out of the+-- continuation lest terrible things happen.+withBinBuffer :: BinHandle -> (ByteString -> IO a) -> IO a+withBinBuffer (BinMem _ ix_r _ arr_r) action = do+  arr <- readIORef arr_r+  ix <- readFastMutInt ix_r+  withForeignPtr arr $ \ptr ->+    BS.unsafePackCStringLen (castPtr ptr, ix) >>= action+++---------------------------------------------------------------+-- Bin+---------------------------------------------------------------++newtype Bin a = BinPtr Int+  deriving (Eq, Ord, Show, Bounded)++castBin :: Bin a -> Bin b+castBin (BinPtr i) = BinPtr i++---------------------------------------------------------------+-- class Binary+---------------------------------------------------------------++-- | Do not rely on instance sizes for general types,+-- we use variable length encoding for many of them.+class Binary a where+    put_   :: BinHandle -> a -> IO ()+    put    :: BinHandle -> a -> IO (Bin a)+    get    :: BinHandle -> IO a++    -- define one of put_, put.  Use of put_ is recommended because it+    -- is more likely that tail-calls can kick in, and we rarely need the+    -- position return value.+    put_ bh a = do _ <- put bh a; return ()+    put bh a  = do p <- tellBin bh; put_ bh a; return p++putAt  :: Binary a => BinHandle -> Bin a -> a -> IO ()+putAt bh p x = do seekBin bh p; put_ bh x; return ()++getAt  :: Binary a => BinHandle -> Bin a -> IO a+getAt bh p = do seekBin bh p; get bh++openBinMem :: Int -> IO BinHandle+openBinMem size+ | size <= 0 = error "Data.Binary.openBinMem: size must be >= 0"+ | otherwise = do+   arr <- mallocForeignPtrBytes size+   arr_r <- newIORef arr+   ix_r <- newFastMutInt+   writeFastMutInt ix_r 0+   sz_r <- newFastMutInt+   writeFastMutInt sz_r size+   return (BinMem noUserData ix_r sz_r arr_r)++tellBin :: BinHandle -> IO (Bin a)+tellBin (BinMem _ r _ _) = do ix <- readFastMutInt r; return (BinPtr ix)++seekBin :: BinHandle -> Bin a -> IO ()+seekBin h@(BinMem _ ix_r sz_r _) (BinPtr !p) = do+  sz <- readFastMutInt sz_r+  if (p >= sz)+        then do expandBin h p; writeFastMutInt ix_r p+        else writeFastMutInt ix_r p++writeBinMem :: BinHandle -> FilePath -> IO ()+writeBinMem (BinMem _ ix_r _ arr_r) fn = do+  h <- openBinaryFile fn WriteMode+  arr <- readIORef arr_r+  ix  <- readFastMutInt ix_r+  withForeignPtr arr $ \p -> hPutBuf h p ix+  hClose h++readBinMem :: FilePath -> IO BinHandle+-- Return a BinHandle with a totally undefined State+readBinMem filename = do+  h <- openBinaryFile filename ReadMode+  filesize' <- hFileSize h+  let filesize = fromIntegral filesize'+  arr <- mallocForeignPtrBytes filesize+  count <- withForeignPtr arr $ \p -> hGetBuf h p filesize+  when (count /= filesize) $+       error ("Binary.readBinMem: only read " ++ show count ++ " bytes")+  hClose h+  arr_r <- newIORef arr+  ix_r <- newFastMutInt+  writeFastMutInt ix_r 0+  sz_r <- newFastMutInt+  writeFastMutInt sz_r filesize+  return (BinMem noUserData ix_r sz_r arr_r)++-- expand the size of the array to include a specified offset+expandBin :: BinHandle -> Int -> IO ()+expandBin (BinMem _ _ sz_r arr_r) !off = do+   !sz <- readFastMutInt sz_r+   let !sz' = getSize sz+   arr <- readIORef arr_r+   arr' <- mallocForeignPtrBytes sz'+   withForeignPtr arr $ \old ->+     withForeignPtr arr' $ \new ->+       copyBytes new old sz+   writeFastMutInt sz_r sz'+   writeIORef arr_r arr'+   where+    getSize :: Int -> Int+    getSize !sz+      | sz > off+      = sz+      | otherwise+      = getSize (sz * 2)++-- -----------------------------------------------------------------------------+-- Low-level reading/writing of bytes++-- | Takes a size and action writing up to @size@ bytes.+--   After the action has run advance the index to the buffer+--   by size bytes.+putPrim :: BinHandle -> Int -> (Ptr Word8 -> IO ()) -> IO ()+putPrim h@(BinMem _ ix_r sz_r arr_r) size f = do+  ix <- readFastMutInt ix_r+  sz <- readFastMutInt sz_r+  when (ix + size > sz) $+    expandBin h (ix + size)+  arr <- readIORef arr_r+  withForeignPtr arr $ \op -> f (op `plusPtr` ix)+  writeFastMutInt ix_r (ix + size)++-- -- | Similar to putPrim but advances the index by the actual number of+-- -- bytes written.+-- putPrimMax :: BinHandle -> Int -> (Ptr Word8 -> IO Int) -> IO ()+-- putPrimMax h@(BinMem _ ix_r sz_r arr_r) size f = do+--   ix <- readFastMutInt ix_r+--   sz <- readFastMutInt sz_r+--   when (ix + size > sz) $+--     expandBin h (ix + size)+--   arr <- readIORef arr_r+--   written <- withForeignPtr arr $ \op -> f (op `plusPtr` ix)+--   writeFastMutInt ix_r (ix + written)++getPrim :: BinHandle -> Int -> (Ptr Word8 -> IO a) -> IO a+getPrim (BinMem _ ix_r sz_r arr_r) size f = do+  ix <- readFastMutInt ix_r+  sz <- readFastMutInt sz_r+  when (ix + size > sz) $+      ioError (mkIOError eofErrorType "Data.Binary.getPrim" Nothing Nothing)+  arr <- readIORef arr_r+  w <- withForeignPtr arr $ \op -> f (op `plusPtr` ix)+  writeFastMutInt ix_r (ix + size)+  return w++putWord8 :: BinHandle -> Word8 -> IO ()+putWord8 h !w = putPrim h 1 (\op -> poke op w)++getWord8 :: BinHandle -> IO Word8+getWord8 h = getPrim h 1 peek++-- putWord16 :: BinHandle -> Word16 -> IO ()+-- putWord16 h w = putPrim h 2 (\op -> do+--   pokeElemOff op 0 (fromIntegral (w `shiftR` 8))+--   pokeElemOff op 1 (fromIntegral (w .&. 0xFF))+--   )++-- getWord16 :: BinHandle -> IO Word16+-- getWord16 h = getPrim h 2 (\op -> do+--   w0 <- fromIntegral <$> peekElemOff op 0+--   w1 <- fromIntegral <$> peekElemOff op 1+--   return $! w0 `shiftL` 8 .|. w1+--   )++putWord32 :: BinHandle -> Word32 -> IO ()+putWord32 h w = putPrim h 4 (\op -> do+  pokeElemOff op 0 (fromIntegral (w `shiftR` 24))+  pokeElemOff op 1 (fromIntegral ((w `shiftR` 16) .&. 0xFF))+  pokeElemOff op 2 (fromIntegral ((w `shiftR` 8) .&. 0xFF))+  pokeElemOff op 3 (fromIntegral (w .&. 0xFF))+  )++getWord32 :: BinHandle -> IO Word32+getWord32 h = getPrim h 4 (\op -> do+  w0 <- fromIntegral <$> peekElemOff op 0+  w1 <- fromIntegral <$> peekElemOff op 1+  w2 <- fromIntegral <$> peekElemOff op 2+  w3 <- fromIntegral <$> peekElemOff op 3++  return $! (w0 `shiftL` 24) .|.+            (w1 `shiftL` 16) .|.+            (w2 `shiftL` 8)  .|.+            w3+  )++-- putWord64 :: BinHandle -> Word64 -> IO ()+-- putWord64 h w = putPrim h 8 (\op -> do+--   pokeElemOff op 0 (fromIntegral (w `shiftR` 56))+--   pokeElemOff op 1 (fromIntegral ((w `shiftR` 48) .&. 0xFF))+--   pokeElemOff op 2 (fromIntegral ((w `shiftR` 40) .&. 0xFF))+--   pokeElemOff op 3 (fromIntegral ((w `shiftR` 32) .&. 0xFF))+--   pokeElemOff op 4 (fromIntegral ((w `shiftR` 24) .&. 0xFF))+--   pokeElemOff op 5 (fromIntegral ((w `shiftR` 16) .&. 0xFF))+--   pokeElemOff op 6 (fromIntegral ((w `shiftR` 8) .&. 0xFF))+--   pokeElemOff op 7 (fromIntegral (w .&. 0xFF))+--   )++-- getWord64 :: BinHandle -> IO Word64+-- getWord64 h = getPrim h 8 (\op -> do+--   w0 <- fromIntegral <$> peekElemOff op 0+--   w1 <- fromIntegral <$> peekElemOff op 1+--   w2 <- fromIntegral <$> peekElemOff op 2+--   w3 <- fromIntegral <$> peekElemOff op 3+--   w4 <- fromIntegral <$> peekElemOff op 4+--   w5 <- fromIntegral <$> peekElemOff op 5+--   w6 <- fromIntegral <$> peekElemOff op 6+--   w7 <- fromIntegral <$> peekElemOff op 7++--   return $! (w0 `shiftL` 56) .|.+--             (w1 `shiftL` 48) .|.+--             (w2 `shiftL` 40) .|.+--             (w3 `shiftL` 32) .|.+--             (w4 `shiftL` 24) .|.+--             (w5 `shiftL` 16) .|.+--             (w6 `shiftL` 8)  .|.+--             w7+--   )++putByte :: BinHandle -> Word8 -> IO ()+putByte bh !w = putWord8 bh w++getByte :: BinHandle -> IO Word8+getByte h = getWord8 h++-- -----------------------------------------------------------------------------+-- Encode numbers in LEB128 encoding.+-- Requires one byte of space per 7 bits of data.+--+-- There are signed and unsigned variants.+-- Do NOT use the unsigned one for signed values, at worst it will+-- result in wrong results, at best it will lead to bad performance+-- when coercing negative values to an unsigned type.+--+-- We mark them as SPECIALIZE as it's extremely critical that they get specialized+-- to their specific types.+--+-- TODO: Each use of putByte performs a bounds check,+--       we should use putPrimMax here. However it's quite hard to return+--       the number of bytes written into putPrimMax without allocating an+--       Int for it, while the code below does not allocate at all.+--       So we eat the cost of the bounds check instead of increasing allocations+--       for now.++-- Unsigned numbers+{-# SPECIALISE putULEB128 :: BinHandle -> Word -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Word64 -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Word32 -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Word16 -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Int -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Int64 -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Int32 -> IO () #-}+{-# SPECIALISE putULEB128 :: BinHandle -> Int16 -> IO () #-}+putULEB128 :: forall a. (Integral a, FiniteBits a) => BinHandle -> a -> IO ()+putULEB128 bh w =+#if defined(DEBUG)+    (if w < 0 then panic "putULEB128: Signed number" else id) $+#endif+    go w+  where+    go :: a -> IO ()+    go w+      | w <= (127 :: a)+      = putByte bh (fromIntegral w :: Word8)+      | otherwise = do+        -- bit 7 (8th bit) indicates more to come.+        let !byte = setBit (fromIntegral w) 7 :: Word8+        putByte bh byte+        go (w `unsafeShiftR` 7)++{-# SPECIALISE getULEB128 :: BinHandle -> IO Word #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Word64 #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Word32 #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Word16 #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Int #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Int64 #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Int32 #-}+{-# SPECIALISE getULEB128 :: BinHandle -> IO Int16 #-}+getULEB128 :: forall a. (Integral a, FiniteBits a) => BinHandle -> IO a+getULEB128 bh =+    go 0 0+  where+    go :: Int -> a -> IO a+    go shift w = do+        b <- getByte bh+        let !hasMore = testBit b 7+        let !val = w .|. ((clearBit (fromIntegral b) 7) `unsafeShiftL` shift) :: a+        if hasMore+            then do+                go (shift+7) val+            else+                return $! val++-- Signed numbers+{-# SPECIALISE putSLEB128 :: BinHandle -> Word -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Word64 -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Word32 -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Word16 -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Int -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Int64 -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Int32 -> IO () #-}+{-# SPECIALISE putSLEB128 :: BinHandle -> Int16 -> IO () #-}+putSLEB128 :: forall a. (Integral a, Bits a) => BinHandle -> a -> IO ()+putSLEB128 bh initial = go initial+  where+    go :: a -> IO ()+    go val = do+        let !byte = fromIntegral (clearBit val 7) :: Word8+        let !val' = val `unsafeShiftR` 7+        let !signBit = testBit byte 6+        let !done =+                -- Unsigned value, val' == 0 and last value can+                -- be discriminated from a negative number.+                ((val' == 0 && not signBit) ||+                -- Signed value,+                 (val' == -1 && signBit))++        let !byte' = if done then byte else setBit byte 7+        putByte bh byte'++        unless done $ go val'++{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word64 #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word32 #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word16 #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int64 #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int32 #-}+{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int16 #-}+getSLEB128 :: forall a. (Show a, Integral a, FiniteBits a) => BinHandle -> IO a+getSLEB128 bh = do+    (val,shift,signed) <- go 0 0+    if signed && (shift < finiteBitSize val )+        then return $! ((complement 0 `unsafeShiftL` shift) .|. val)+        else return val+    where+        go :: Int -> a -> IO (a,Int,Bool)+        go shift val = do+            byte <- getByte bh+            let !byteVal = fromIntegral (clearBit byte 7) :: a+            let !val' = val .|. (byteVal `unsafeShiftL` shift)+            let !more = testBit byte 7+            let !shift' = shift+7+            if more+                then go (shift') val'+                else do+                    let !signed = testBit byte 6+                    return (val',shift',signed)++-- -----------------------------------------------------------------------------+-- Primitive Word writes++instance Binary Word8 where+  put_ bh !w = putWord8 bh w+  get  = getWord8++instance Binary Word16 where+  put_ = putULEB128+  get  = getULEB128++instance Binary Word32 where+  put_ = putULEB128+  get  = getULEB128++instance Binary Word64 where+  put_ = putULEB128+  get = getULEB128++-- -----------------------------------------------------------------------------+-- Primitive Int writes++instance Binary Int8 where+  put_ h w = put_ h (fromIntegral w :: Word8)+  get h    = do w <- get h; return $! (fromIntegral (w::Word8))++instance Binary Int16 where+  put_ = putSLEB128+  get = getSLEB128++instance Binary Int32 where+  put_ = putSLEB128+  get = getSLEB128++instance Binary Int64 where+  put_ h w = putSLEB128 h w+  get h    = getSLEB128 h++-- -----------------------------------------------------------------------------+-- Instances for standard types++instance Binary () where+    put_ _ () = return ()+    get  _    = return ()++instance Binary Bool where+    put_ bh b = putByte bh (fromIntegral (fromEnum b))+    get  bh   = do x <- getWord8 bh; return $! (toEnum (fromIntegral x))++instance Binary Char where+    put_  bh c = put_ bh (fromIntegral (ord c) :: Word32)+    get  bh   = do x <- get bh; return $! (chr (fromIntegral (x :: Word32)))++instance Binary Int where+    put_ bh i = put_ bh (fromIntegral i :: Int64)+    get  bh = do+        x <- get bh+        return $! (fromIntegral (x :: Int64))++instance Binary a => Binary [a] where+    put_ bh l = do+        let len = length l+        put_ bh len+        mapM_ (put_ bh) l+    get bh = do+        len <- get bh :: IO Int -- Int is variable length encoded so only+                                -- one byte for small lists.+        let loop 0 = return []+            loop n = do a <- get bh; as <- loop (n-1); return (a:as)+        loop len++instance (Ix a, Binary a, Binary b) => Binary (Array a b) where+    put_ bh arr = do+        put_ bh $ bounds arr+        put_ bh $ elems arr+    get bh = do+        bounds <- get bh+        xs <- get bh+        return $ listArray bounds xs++instance (Binary a, Binary b) => Binary (a,b) where+    put_ bh (a,b) = do put_ bh a; put_ bh b+    get bh        = do a <- get bh+                       b <- get bh+                       return (a,b)++instance (Binary a, Binary b, Binary c) => Binary (a,b,c) where+    put_ bh (a,b,c) = do put_ bh a; put_ bh b; put_ bh c+    get bh          = do a <- get bh+                         b <- get bh+                         c <- get bh+                         return (a,b,c)++instance (Binary a, Binary b, Binary c, Binary d) => Binary (a,b,c,d) where+    put_ bh (a,b,c,d) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d+    get bh            = do a <- get bh+                           b <- get bh+                           c <- get bh+                           d <- get bh+                           return (a,b,c,d)++instance (Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a,b,c,d, e) where+    put_ bh (a,b,c,d, e) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e;+    get bh               = do a <- get bh+                              b <- get bh+                              c <- get bh+                              d <- get bh+                              e <- get bh+                              return (a,b,c,d,e)++instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a,b,c,d, e, f) where+    put_ bh (a,b,c,d, e, f) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e; put_ bh f;+    get bh                  = do a <- get bh+                                 b <- get bh+                                 c <- get bh+                                 d <- get bh+                                 e <- get bh+                                 f <- get bh+                                 return (a,b,c,d,e,f)++instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a,b,c,d,e,f,g) where+    put_ bh (a,b,c,d,e,f,g) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e; put_ bh f; put_ bh g+    get bh                  = do a <- get bh+                                 b <- get bh+                                 c <- get bh+                                 d <- get bh+                                 e <- get bh+                                 f <- get bh+                                 g <- get bh+                                 return (a,b,c,d,e,f,g)++instance Binary a => Binary (Maybe a) where+    put_ bh Nothing  = putByte bh 0+    put_ bh (Just a) = do putByte bh 1; put_ bh a+    get bh           = do h <- getWord8 bh+                          case h of+                            0 -> return Nothing+                            _ -> do x <- get bh; return (Just x)++instance (Binary a, Binary b) => Binary (Either a b) where+    put_ bh (Left  a) = do putByte bh 0; put_ bh a+    put_ bh (Right b) = do putByte bh 1; put_ bh b+    get bh            = do h <- getWord8 bh+                           case h of+                             0 -> do a <- get bh ; return (Left a)+                             _ -> do b <- get bh ; return (Right b)++instance Binary UTCTime where+    put_ bh u = do put_ bh (utctDay u)+                   put_ bh (utctDayTime u)+    get bh = do day <- get bh+                dayTime <- get bh+                return $ UTCTime { utctDay = day, utctDayTime = dayTime }++instance Binary Day where+    put_ bh d = put_ bh (toModifiedJulianDay d)+    get bh = do i <- get bh+                return $ ModifiedJulianDay { toModifiedJulianDay = i }++instance Binary DiffTime where+    put_ bh dt = put_ bh (toRational dt)+    get bh = do r <- get bh+                return $ fromRational r++{-+Finally - a reasonable portable Integer instance.++We used to encode values in the Int32 range as such,+falling back to a string of all things. In either case+we stored a tag byte to discriminate between the two cases.++This made some sense as it's highly portable but also not very+efficient.++However GHC stores a surprisingly large number off large Integer+values. In the examples looked at between 25% and 50% of Integers+serialized were outside of the Int32 range.++Consider a valie like `2724268014499746065`, some sort of hash+actually generated by GHC.+In the old scheme this was encoded as a list of 19 chars. This+gave a size of 77 Bytes, one for the length of the list and 76+since we encode chars as Word32 as well.++We can easily do better. The new plan is:++* Start with a tag byte+  * 0 => Int64 (LEB128 encoded)+  * 1 => Negative large interger+  * 2 => Positive large integer+* Followed by the value:+  * Int64 is encoded as usual+  * Large integers are encoded as a list of bytes (Word8).+    We use Data.Bits which defines a bit order independent of the representation.+    Values are stored LSB first.++This means our example value `2724268014499746065` is now only 10 bytes large.+* One byte tag+* One byte for the length of the [Word8] list.+* 8 bytes for the actual date.++The new scheme also does not depend in any way on+architecture specific details.++We still use this scheme even with LEB128 available,+as it has less overhead for truly large numbers. (> maxBound :: Int64)++The instance is used for in Binary Integer and Binary Rational in GHC.Types.Literal+-}++instance Binary Integer where+    put_ bh i+      | i >= lo64 && i <= hi64 = do+          putWord8 bh 0+          put_ bh (fromIntegral i :: Int64)+      | otherwise = do+          if i < 0+            then putWord8 bh 1+            else putWord8 bh 2+          put_ bh (unroll $ abs i)+      where+        lo64 = fromIntegral (minBound :: Int64)+        hi64 = fromIntegral (maxBound :: Int64)+    get bh = do+      int_kind <- getWord8 bh+      case int_kind of+        0 -> fromIntegral <$!> (get bh :: IO Int64)+        -- Large integer+        1 -> negate <$!> getInt+        2 -> getInt+        _ -> panic "Binary Integer - Invalid byte"+        where+          getInt :: IO Integer+          getInt = roll <$!> (get bh :: IO [Word8])++unroll :: Integer -> [Word8]+unroll = unfoldr step+  where+    step 0 = Nothing+    step i = Just (fromIntegral i, i `shiftR` 8)++roll :: [Word8] -> Integer+roll   = foldl' unstep 0 . reverse+  where+    unstep a b = a `shiftL` 8 .|. fromIntegral b+++    {-+    -- This code is currently commented out.+    -- See https://gitlab.haskell.org/ghc/ghc/issues/3379#note_104346 for+    -- discussion.++    put_ bh (S# i#) = do putByte bh 0; put_ bh (I# i#)+    put_ bh (J# s# a#) = do+        putByte bh 1+        put_ bh (I# s#)+        let sz# = sizeofByteArray# a#  -- in *bytes*+        put_ bh (I# sz#)  -- in *bytes*+        putByteArray bh a# sz#++    get bh = do+        b <- getByte bh+        case b of+          0 -> do (I# i#) <- get bh+                  return (S# i#)+          _ -> do (I# s#) <- get bh+                  sz <- get bh+                  (BA a#) <- getByteArray bh sz+                  return (J# s# a#)++putByteArray :: BinHandle -> ByteArray# -> Int# -> IO ()+putByteArray bh a s# = loop 0#+  where loop n#+           | n# ==# s# = return ()+           | otherwise = do+                putByte bh (indexByteArray a n#)+                loop (n# +# 1#)++getByteArray :: BinHandle -> Int -> IO ByteArray+getByteArray bh (I# sz) = do+  (MBA arr) <- newByteArray sz+  let loop n+           | n ==# sz = return ()+           | otherwise = do+                w <- getByte bh+                writeByteArray arr n w+                loop (n +# 1#)+  loop 0#+  freezeByteArray arr+    -}++{-+data ByteArray = BA ByteArray#+data MBA = MBA (MutableByteArray# RealWorld)++newByteArray :: Int# -> IO MBA+newByteArray sz = IO $ \s ->+  case newByteArray# sz s of { (# s, arr #) ->+  (# s, MBA arr #) }++freezeByteArray :: MutableByteArray# RealWorld -> IO ByteArray+freezeByteArray arr = IO $ \s ->+  case unsafeFreezeByteArray# arr s of { (# s, arr #) ->+  (# s, BA arr #) }++writeByteArray :: MutableByteArray# RealWorld -> Int# -> Word8 -> IO ()+writeByteArray arr i (W8# w) = IO $ \s ->+  case writeWord8Array# arr i w s of { s ->+  (# s, () #) }++indexByteArray :: ByteArray# -> Int# -> Word8+indexByteArray a# n# = W8# (indexWord8Array# a# n#)++-}+instance (Binary a) => Binary (Ratio a) where+    put_ bh (a :% b) = do put_ bh a; put_ bh b+    get bh = do a <- get bh; b <- get bh; return (a :% b)++-- Instance uses fixed-width encoding to allow inserting+-- Bin placeholders in the stream.+instance Binary (Bin a) where+  put_ bh (BinPtr i) = putWord32 bh (fromIntegral i :: Word32)+  get bh = do i <- getWord32 bh; return (BinPtr (fromIntegral (i :: Word32)))++-- -----------------------------------------------------------------------------+-- Instances for Data.Typeable stuff++instance Binary TyCon where+    put_ bh tc = do+        put_ bh (tyConPackage tc)+        put_ bh (tyConModule tc)+        put_ bh (tyConName tc)+        put_ bh (tyConKindArgs tc)+        put_ bh (tyConKindRep tc)+    get bh =+        mkTyCon <$> get bh <*> get bh <*> get bh <*> get bh <*> get bh++instance Binary VecCount where+    put_ bh = putByte bh . fromIntegral . fromEnum+    get bh = toEnum . fromIntegral <$> getByte bh++instance Binary VecElem where+    put_ bh = putByte bh . fromIntegral . fromEnum+    get bh = toEnum . fromIntegral <$> getByte bh++instance Binary RuntimeRep where+    put_ bh (VecRep a b)    = putByte bh 0 >> put_ bh a >> put_ bh b+    put_ bh (TupleRep reps) = putByte bh 1 >> put_ bh reps+    put_ bh (SumRep reps)   = putByte bh 2 >> put_ bh reps+    put_ bh LiftedRep       = putByte bh 3+    put_ bh UnliftedRep     = putByte bh 4+    put_ bh IntRep          = putByte bh 5+    put_ bh WordRep         = putByte bh 6+    put_ bh Int64Rep        = putByte bh 7+    put_ bh Word64Rep       = putByte bh 8+    put_ bh AddrRep         = putByte bh 9+    put_ bh FloatRep        = putByte bh 10+    put_ bh DoubleRep       = putByte bh 11+    put_ bh Int8Rep         = putByte bh 12+    put_ bh Word8Rep        = putByte bh 13+    put_ bh Int16Rep        = putByte bh 14+    put_ bh Word16Rep       = putByte bh 15+#if __GLASGOW_HASKELL__ >= 809+    put_ bh Int32Rep        = putByte bh 16+    put_ bh Word32Rep       = putByte bh 17+#endif++    get bh = do+        tag <- getByte bh+        case tag of+          0  -> VecRep <$> get bh <*> get bh+          1  -> TupleRep <$> get bh+          2  -> SumRep <$> get bh+          3  -> pure LiftedRep+          4  -> pure UnliftedRep+          5  -> pure IntRep+          6  -> pure WordRep+          7  -> pure Int64Rep+          8  -> pure Word64Rep+          9  -> pure AddrRep+          10 -> pure FloatRep+          11 -> pure DoubleRep+          12 -> pure Int8Rep+          13 -> pure Word8Rep+          14 -> pure Int16Rep+          15 -> pure Word16Rep+#if __GLASGOW_HASKELL__ >= 809+          16 -> pure Int32Rep+          17 -> pure Word32Rep+#endif+          _  -> fail "Binary.putRuntimeRep: invalid tag"++instance Binary KindRep where+    put_ bh (KindRepTyConApp tc k) = putByte bh 0 >> put_ bh tc >> put_ bh k+    put_ bh (KindRepVar bndr) = putByte bh 1 >> put_ bh bndr+    put_ bh (KindRepApp a b) = putByte bh 2 >> put_ bh a >> put_ bh b+    put_ bh (KindRepFun a b) = putByte bh 3 >> put_ bh a >> put_ bh b+    put_ bh (KindRepTYPE r) = putByte bh 4 >> put_ bh r+    put_ bh (KindRepTypeLit sort r) = putByte bh 5 >> put_ bh sort >> put_ bh r++    get bh = do+        tag <- getByte bh+        case tag of+          0 -> KindRepTyConApp <$> get bh <*> get bh+          1 -> KindRepVar <$> get bh+          2 -> KindRepApp <$> get bh <*> get bh+          3 -> KindRepFun <$> get bh <*> get bh+          4 -> KindRepTYPE <$> get bh+          5 -> KindRepTypeLit <$> get bh <*> get bh+          _ -> fail "Binary.putKindRep: invalid tag"++instance Binary TypeLitSort where+    put_ bh TypeLitSymbol = putByte bh 0+    put_ bh TypeLitNat = putByte bh 1+    get bh = do+        tag <- getByte bh+        case tag of+          0 -> pure TypeLitSymbol+          1 -> pure TypeLitNat+          _ -> fail "Binary.putTypeLitSort: invalid tag"++putTypeRep :: BinHandle -> TypeRep a -> IO ()+-- Special handling for TYPE, (->), and RuntimeRep due to recursive kind+-- relations.+-- See Note [Mutually recursive representations of primitive types]+putTypeRep bh rep+  | Just HRefl <- rep `eqTypeRep` (typeRep :: TypeRep Type)+  = put_ bh (0 :: Word8)+putTypeRep bh (Con' con ks) = do+    put_ bh (1 :: Word8)+    put_ bh con+    put_ bh ks+putTypeRep bh (App f x) = do+    put_ bh (2 :: Word8)+    putTypeRep bh f+    putTypeRep bh x+putTypeRep bh (Fun arg res) = do+    put_ bh (3 :: Word8)+    putTypeRep bh arg+    putTypeRep bh res++getSomeTypeRep :: BinHandle -> IO SomeTypeRep+getSomeTypeRep bh = do+    tag <- get bh :: IO Word8+    case tag of+        0 -> return $ SomeTypeRep (typeRep :: TypeRep Type)+        1 -> do con <- get bh :: IO TyCon+                ks <- get bh :: IO [SomeTypeRep]+                return $ SomeTypeRep $ mkTrCon con ks++        2 -> do SomeTypeRep f <- getSomeTypeRep bh+                SomeTypeRep x <- getSomeTypeRep bh+                case typeRepKind f of+                  Fun arg res ->+                      case arg `eqTypeRep` typeRepKind x of+                        Just HRefl ->+                            case typeRepKind res `eqTypeRep` (typeRep :: TypeRep Type) of+                              Just HRefl -> return $ SomeTypeRep $ mkTrApp f x+                              _ -> failure "Kind mismatch in type application" []+                        _ -> failure "Kind mismatch in type application"+                             [ "    Found argument of kind: " ++ show (typeRepKind x)+                             , "    Where the constructor:  " ++ show f+                             , "    Expects kind:           " ++ show arg+                             ]+                  _ -> failure "Applied non-arrow"+                       [ "    Applied type: " ++ show f+                       , "    To argument:  " ++ show x+                       ]+        3 -> do SomeTypeRep arg <- getSomeTypeRep bh+                SomeTypeRep res <- getSomeTypeRep bh+                if+                  | App argkcon _ <- typeRepKind arg+                  , App reskcon _ <- typeRepKind res+                  , Just HRefl <- argkcon `eqTypeRep` tYPErep+                  , Just HRefl <- reskcon `eqTypeRep` tYPErep+                  -> return $ SomeTypeRep $ Fun arg res+                  | otherwise -> failure "Kind mismatch" []+        _ -> failure "Invalid SomeTypeRep" []+  where+    tYPErep :: TypeRep TYPE+    tYPErep = typeRep++    failure description info =+        fail $ unlines $ [ "Binary.getSomeTypeRep: "++description ]+                      ++ map ("    "++) info++instance Typeable a => Binary (TypeRep (a :: k)) where+    put_ = putTypeRep+    get bh = do+        SomeTypeRep rep <- getSomeTypeRep bh+        case rep `eqTypeRep` expected of+            Just HRefl -> pure rep+            Nothing    -> fail $ unlines+                               [ "Binary: Type mismatch"+                               , "    Deserialized type: " ++ show rep+                               , "    Expected type:     " ++ show expected+                               ]+     where expected = typeRep :: TypeRep a++instance Binary SomeTypeRep where+    put_ bh (SomeTypeRep rep) = putTypeRep bh rep+    get = getSomeTypeRep++-- -----------------------------------------------------------------------------+-- Lazy reading/writing++lazyPut :: Binary a => BinHandle -> a -> IO ()+lazyPut bh a = do+    -- output the obj with a ptr to skip over it:+    pre_a <- tellBin bh+    put_ bh pre_a       -- save a slot for the ptr+    put_ bh a           -- dump the object+    q <- tellBin bh     -- q = ptr to after object+    putAt bh pre_a q    -- fill in slot before a with ptr to q+    seekBin bh q        -- finally carry on writing at q++lazyGet :: Binary a => BinHandle -> IO a+lazyGet bh = do+    p <- get bh -- a BinPtr+    p_a <- tellBin bh+    a <- unsafeInterleaveIO $ do+        -- NB: Use a fresh off_r variable in the child thread, for thread+        -- safety.+        off_r <- newFastMutInt+        getAt bh { _off_r = off_r } p_a+    seekBin bh p -- skip over the object for now+    return a++-- -----------------------------------------------------------------------------+-- UserData+-- -----------------------------------------------------------------------------++-- | Information we keep around during interface file+-- serialization/deserialization. Namely we keep the functions for serializing+-- and deserializing 'Name's and 'FastString's. We do this because we actually+-- use serialization in two distinct settings,+--+-- * When serializing interface files themselves+--+-- * When computing the fingerprint of an IfaceDecl (which we computing by+--   hashing its Binary serialization)+--+-- These two settings have different needs while serializing Names:+--+-- * Names in interface files are serialized via a symbol table (see Note+--   [Symbol table representation of names] in GHC.Iface.Binary).+--+-- * During fingerprinting a binding Name is serialized as the OccName and a+--   non-binding Name is serialized as the fingerprint of the thing they+--   represent. See Note [Fingerprinting IfaceDecls] for further discussion.+--+data UserData =+   UserData {+        -- for *deserialising* only:+        ud_get_name :: BinHandle -> IO Name,+        ud_get_fs   :: BinHandle -> IO FastString,++        -- for *serialising* only:+        ud_put_nonbinding_name :: BinHandle -> Name -> IO (),+        -- ^ serialize a non-binding 'Name' (e.g. a reference to another+        -- binding).+        ud_put_binding_name :: BinHandle -> Name -> IO (),+        -- ^ serialize a binding 'Name' (e.g. the name of an IfaceDecl)+        ud_put_fs   :: BinHandle -> FastString -> IO ()+   }++newReadState :: (BinHandle -> IO Name)   -- ^ how to deserialize 'Name's+             -> (BinHandle -> IO FastString)+             -> UserData+newReadState get_name get_fs+  = UserData { ud_get_name = get_name,+               ud_get_fs   = get_fs,+               ud_put_nonbinding_name = undef "put_nonbinding_name",+               ud_put_binding_name    = undef "put_binding_name",+               ud_put_fs   = undef "put_fs"+             }++newWriteState :: (BinHandle -> Name -> IO ())+                 -- ^ how to serialize non-binding 'Name's+              -> (BinHandle -> Name -> IO ())+                 -- ^ how to serialize binding 'Name's+              -> (BinHandle -> FastString -> IO ())+              -> UserData+newWriteState put_nonbinding_name put_binding_name put_fs+  = UserData { ud_get_name = undef "get_name",+               ud_get_fs   = undef "get_fs",+               ud_put_nonbinding_name = put_nonbinding_name,+               ud_put_binding_name    = put_binding_name,+               ud_put_fs   = put_fs+             }++noUserData :: a+noUserData = undef "UserData"++undef :: String -> a+undef s = panic ("Binary.UserData: no " ++ s)++---------------------------------------------------------+-- The Dictionary+---------------------------------------------------------++type Dictionary = Array Int FastString -- The dictionary+                                       -- Should be 0-indexed++putDictionary :: BinHandle -> Int -> UniqFM (Int,FastString) -> IO ()+putDictionary bh sz dict = do+  put_ bh sz+  mapM_ (putFS bh) (elems (array (0,sz-1) (nonDetEltsUFM dict)))+    -- It's OK to use nonDetEltsUFM here because the elements have indices+    -- that array uses to create order++getDictionary :: BinHandle -> IO Dictionary+getDictionary bh = do+  sz <- get bh+  elems <- sequence (take sz (repeat (getFS bh)))+  return (listArray (0,sz-1) elems)++---------------------------------------------------------+-- The Symbol Table+---------------------------------------------------------++-- On disk, the symbol table is an array of IfExtName, when+-- reading it in we turn it into a SymbolTable.++type SymbolTable = Array Int Name++---------------------------------------------------------+-- Reading and writing FastStrings+---------------------------------------------------------++putFS :: BinHandle -> FastString -> IO ()+putFS bh fs = putBS bh $ bytesFS fs++getFS :: BinHandle -> IO FastString+getFS bh = do+  l  <- get bh :: IO Int+  getPrim bh l (\src -> pure $! mkFastStringBytes src l )++putBS :: BinHandle -> ByteString -> IO ()+putBS bh bs =+  BS.unsafeUseAsCStringLen bs $ \(ptr, l) -> do+    put_ bh l+    putPrim bh l (\op -> BS.memcpy op (castPtr ptr) l)++getBS :: BinHandle -> IO ByteString+getBS bh = do+  l <- get bh :: IO Int+  BS.create l $ \dest -> do+    getPrim bh l (\src -> BS.memcpy dest src l)++instance Binary ByteString where+  put_ bh f = putBS bh f+  get bh = getBS bh++instance Binary FastString where+  put_ bh f =+    case getUserData bh of+        UserData { ud_put_fs = put_fs } -> put_fs bh f++  get bh =+    case getUserData bh of+        UserData { ud_get_fs = get_fs } -> get_fs bh++-- Here to avoid loop+instance Binary LeftOrRight where+   put_ bh CLeft  = putByte bh 0+   put_ bh CRight = putByte bh 1++   get bh = do { h <- getByte bh+               ; case h of+                   0 -> return CLeft+                   _ -> return CRight }++instance Binary PromotionFlag where+   put_ bh NotPromoted = putByte bh 0+   put_ bh IsPromoted  = putByte bh 1++   get bh = do+       n <- getByte bh+       case n of+         0 -> return NotPromoted+         1 -> return IsPromoted+         _ -> fail "Binary(IsPromoted): fail)"++instance Binary Fingerprint where+  put_ h (Fingerprint w1 w2) = do put_ h w1; put_ h w2+  get  h = do w1 <- get h; w2 <- get h; return (Fingerprint w1 w2)++instance Binary FunctionOrData where+    put_ bh IsFunction = putByte bh 0+    put_ bh IsData     = putByte bh 1+    get bh = do+        h <- getByte bh+        case h of+          0 -> return IsFunction+          1 -> return IsData+          _ -> panic "Binary FunctionOrData"++instance Binary TupleSort where+    put_ bh BoxedTuple      = putByte bh 0+    put_ bh UnboxedTuple    = putByte bh 1+    put_ bh ConstraintTuple = putByte bh 2+    get bh = do+      h <- getByte bh+      case h of+        0 -> do return BoxedTuple+        1 -> do return UnboxedTuple+        _ -> do return ConstraintTuple++instance Binary Activation where+    put_ bh NeverActive = do+            putByte bh 0+    put_ bh AlwaysActive = do+            putByte bh 1+    put_ bh (ActiveBefore src aa) = do+            putByte bh 2+            put_ bh src+            put_ bh aa+    put_ bh (ActiveAfter src ab) = do+            putByte bh 3+            put_ bh src+            put_ bh ab+    get bh = do+            h <- getByte bh+            case h of+              0 -> do return NeverActive+              1 -> do return AlwaysActive+              2 -> do src <- get bh+                      aa <- get bh+                      return (ActiveBefore src aa)+              _ -> do src <- get bh+                      ab <- get bh+                      return (ActiveAfter src ab)++instance Binary InlinePragma where+    put_ bh (InlinePragma s a b c d) = do+            put_ bh s+            put_ bh a+            put_ bh b+            put_ bh c+            put_ bh d++    get bh = do+           s <- get bh+           a <- get bh+           b <- get bh+           c <- get bh+           d <- get bh+           return (InlinePragma s a b c d)++instance Binary RuleMatchInfo where+    put_ bh FunLike = putByte bh 0+    put_ bh ConLike = putByte bh 1+    get bh = do+            h <- getByte bh+            if h == 1 then return ConLike+                      else return FunLike++instance Binary InlineSpec where+    put_ bh NoUserInline    = putByte bh 0+    put_ bh Inline          = putByte bh 1+    put_ bh Inlinable       = putByte bh 2+    put_ bh NoInline        = putByte bh 3++    get bh = do h <- getByte bh+                case h of+                  0 -> return NoUserInline+                  1 -> return Inline+                  2 -> return Inlinable+                  _ -> return NoInline++instance Binary RecFlag where+    put_ bh Recursive = do+            putByte bh 0+    put_ bh NonRecursive = do+            putByte bh 1+    get bh = do+            h <- getByte bh+            case h of+              0 -> do return Recursive+              _ -> do return NonRecursive++instance Binary OverlapMode where+    put_ bh (NoOverlap    s) = putByte bh 0 >> put_ bh s+    put_ bh (Overlaps     s) = putByte bh 1 >> put_ bh s+    put_ bh (Incoherent   s) = putByte bh 2 >> put_ bh s+    put_ bh (Overlapping  s) = putByte bh 3 >> put_ bh s+    put_ bh (Overlappable s) = putByte bh 4 >> put_ bh s+    get bh = do+        h <- getByte bh+        case h of+            0 -> (get bh) >>= \s -> return $ NoOverlap s+            1 -> (get bh) >>= \s -> return $ Overlaps s+            2 -> (get bh) >>= \s -> return $ Incoherent s+            3 -> (get bh) >>= \s -> return $ Overlapping s+            4 -> (get bh) >>= \s -> return $ Overlappable s+            _ -> panic ("get OverlapMode" ++ show h)+++instance Binary OverlapFlag where+    put_ bh flag = do put_ bh (overlapMode flag)+                      put_ bh (isSafeOverlap flag)+    get bh = do+        h <- get bh+        b <- get bh+        return OverlapFlag { overlapMode = h, isSafeOverlap = b }++instance Binary FixityDirection where+    put_ bh InfixL = do+            putByte bh 0+    put_ bh InfixR = do+            putByte bh 1+    put_ bh InfixN = do+            putByte bh 2+    get bh = do+            h <- getByte bh+            case h of+              0 -> do return InfixL+              1 -> do return InfixR+              _ -> do return InfixN++instance Binary Fixity where+    put_ bh (Fixity src aa ab) = do+            put_ bh src+            put_ bh aa+            put_ bh ab+    get bh = do+          src <- get bh+          aa <- get bh+          ab <- get bh+          return (Fixity src aa ab)++instance Binary WarningTxt where+    put_ bh (WarningTxt s w) = do+            putByte bh 0+            put_ bh s+            put_ bh w+    put_ bh (DeprecatedTxt s d) = do+            putByte bh 1+            put_ bh s+            put_ bh d++    get bh = do+            h <- getByte bh+            case h of+              0 -> do s <- get bh+                      w <- get bh+                      return (WarningTxt s w)+              _ -> do s <- get bh+                      d <- get bh+                      return (DeprecatedTxt s d)++instance Binary StringLiteral where+  put_ bh (StringLiteral st fs) = do+            put_ bh st+            put_ bh fs+  get bh = do+            st <- get bh+            fs <- get bh+            return (StringLiteral st fs)++instance Binary a => Binary (Located a) where+    put_ bh (L l x) = do+            put_ bh l+            put_ bh x++    get bh = do+            l <- get bh+            x <- get bh+            return (L l x)++instance Binary RealSrcSpan where+  put_ bh ss = do+            put_ bh (srcSpanFile ss)+            put_ bh (srcSpanStartLine ss)+            put_ bh (srcSpanStartCol ss)+            put_ bh (srcSpanEndLine ss)+            put_ bh (srcSpanEndCol ss)++  get bh = do+            f <- get bh+            sl <- get bh+            sc <- get bh+            el <- get bh+            ec <- get bh+            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 sb) = do+          putByte bh 0+          put_ bh ss+          put_ bh sb++  put_ bh (UnhelpfulSpan s) = do+          putByte bh 1+          put_ bh s++  get bh = do+          h <- getByte bh+          case h of+            0 -> do ss <- get bh+                    sb <- get bh+                    return (RealSrcSpan ss sb)+            _ -> do s <- get bh+                    return (UnhelpfulSpan s)++instance Binary Serialized where+    put_ bh (Serialized the_type bytes) = do+        put_ bh the_type+        put_ bh bytes+    get bh = do+        the_type <- get bh+        bytes <- get bh+        return (Serialized the_type bytes)++instance Binary SourceText where+  put_ bh NoSourceText = putByte bh 0+  put_ bh (SourceText s) = do+        putByte bh 1+        put_ bh s++  get bh = do+    h <- getByte bh+    case h of+      0 -> return NoSourceText+      1 -> do+        s <- get bh+        return (SourceText s)+      _ -> panic $ "Binary SourceText:" ++ show h
+ compiler/GHC/Utils/BufHandle.hs view
@@ -0,0 +1,145 @@+{-# LANGUAGE BangPatterns #-}++-----------------------------------------------------------------------------+--+-- Fast write-buffered Handles+--+-- (c) The University of Glasgow 2005-2006+--+-- This is a simple abstraction over Handles that offers very fast write+-- buffering, but without the thread safety that Handles provide.  It's used+-- to save time in GHC.Utils.Ppr.printDoc.+--+-----------------------------------------------------------------------------++module GHC.Utils.BufHandle (+        BufHandle(..),+        newBufHandle,+        bPutChar,+        bPutStr,+        bPutFS,+        bPutFZS,+        bPutPtrString,+        bPutReplicate,+        bFlush,+  ) where++import GHC.Prelude++import GHC.Data.FastString+import GHC.Data.FastMutInt++import Control.Monad    ( when )+import Data.ByteString (ByteString)+import qualified Data.ByteString.Unsafe as BS+import Data.Char        ( ord )+import Foreign+import Foreign.C.String+import System.IO++-- -----------------------------------------------------------------------------++data BufHandle = BufHandle {-#UNPACK#-}!(Ptr Word8)+                           {-#UNPACK#-}!FastMutInt+                           Handle++newBufHandle :: Handle -> IO BufHandle+newBufHandle hdl = do+  ptr <- mallocBytes buf_size+  r <- newFastMutInt+  writeFastMutInt r 0+  return (BufHandle ptr r hdl)++buf_size :: Int+buf_size = 8192++bPutChar :: BufHandle -> Char -> IO ()+bPutChar b@(BufHandle buf r hdl) !c = do+  i <- readFastMutInt r+  if (i >= buf_size)+        then do hPutBuf hdl buf buf_size+                writeFastMutInt r 0+                bPutChar b c+        else do pokeElemOff buf i (fromIntegral (ord c) :: Word8)+                writeFastMutInt r (i+1)++bPutStr :: BufHandle -> String -> IO ()+bPutStr (BufHandle buf r hdl) !str = do+  i <- readFastMutInt r+  loop str i+  where loop "" !i = do writeFastMutInt r i; return ()+        loop (c:cs) !i+           | i >= buf_size = do+                hPutBuf hdl buf buf_size+                loop (c:cs) 0+           | otherwise = do+                pokeElemOff buf i (fromIntegral (ord c))+                loop cs (i+1)++bPutFS :: BufHandle -> FastString -> IO ()+bPutFS b fs = bPutBS b $ bytesFS fs++bPutFZS :: BufHandle -> FastZString -> IO ()+bPutFZS b fs = bPutBS b $ fastZStringToByteString fs++bPutBS :: BufHandle -> ByteString -> IO ()+bPutBS b bs = BS.unsafeUseAsCStringLen bs $ bPutCStringLen b++bPutCStringLen :: BufHandle -> CStringLen -> IO ()+bPutCStringLen b@(BufHandle buf r hdl) cstr@(ptr, len) = do+  i <- readFastMutInt r+  if (i + len) >= buf_size+        then do hPutBuf hdl buf i+                writeFastMutInt r 0+                if (len >= buf_size)+                    then hPutBuf hdl ptr len+                    else bPutCStringLen b cstr+        else do+                copyBytes (buf `plusPtr` i) ptr len+                writeFastMutInt r (i + len)++bPutPtrString :: BufHandle -> PtrString -> IO ()+bPutPtrString b@(BufHandle buf r hdl) l@(PtrString a len) = l `seq` do+  i <- readFastMutInt r+  if (i+len) >= buf_size+        then do hPutBuf hdl buf i+                writeFastMutInt r 0+                if (len >= buf_size)+                    then hPutBuf hdl a len+                    else bPutPtrString b l+        else do+                copyBytes (buf `plusPtr` i) a len+                writeFastMutInt r (i+len)++-- | Replicate an 8-bit character+bPutReplicate :: BufHandle -> Int -> Char -> IO ()+bPutReplicate (BufHandle buf r hdl) len c = do+  i <- readFastMutInt r+  let oc = fromIntegral (ord c)+  if (i+len) < buf_size+    then do+      fillBytes (buf `plusPtr` i) oc len+      writeFastMutInt r (i+len)+    else do+      -- flush the current buffer+      when (i /= 0) $ hPutBuf hdl buf i+      if (len < buf_size)+        then do+          fillBytes buf oc len+          writeFastMutInt r len+        else do+          -- fill a full buffer+          fillBytes buf oc buf_size+          -- flush it as many times as necessary+          let go n | n >= buf_size = do+                                       hPutBuf hdl buf buf_size+                                       go (n-buf_size)+                   | otherwise     = writeFastMutInt r n+          go len++bFlush :: BufHandle -> IO ()+bFlush (BufHandle buf r hdl) = do+  i <- readFastMutInt r+  when (i > 0) $ hPutBuf hdl buf i+  free buf+  return ()
+ compiler/GHC/Utils/CliOption.hs view
@@ -0,0 +1,27 @@+module GHC.Utils.CliOption+  ( Option (..)+  , showOpt+  ) where++import GHC.Prelude++-- -----------------------------------------------------------------------------+-- Command-line options++-- | When invoking external tools as part of the compilation pipeline, we+-- pass these a sequence of options on the command-line. Rather than+-- just using a list of Strings, we use a type that allows us to distinguish+-- between filepaths and 'other stuff'. The reason for this is that+-- this type gives us a handle on transforming filenames, and filenames only,+-- to whatever format they're expected to be on a particular platform.+data Option+ = FileOption -- an entry that _contains_ filename(s) / filepaths.+              String  -- a non-filepath prefix that shouldn't be+                      -- transformed (e.g., "/out=")+              String  -- the filepath/filename portion+ | Option     String+ deriving ( Eq )++showOpt :: Option -> String+showOpt (FileOption pre f) = pre ++ f+showOpt (Option s)  = s
+ compiler/GHC/Utils/Encoding.hs view
@@ -0,0 +1,450 @@+{-# LANGUAGE BangPatterns, MagicHash, UnboxedTuples #-}+{-# OPTIONS_GHC -O2 #-}+-- We always optimise this, otherwise performance of a non-optimised+-- compiler is severely affected++-- -----------------------------------------------------------------------------+--+-- (c) The University of Glasgow, 1997-2006+--+-- Character encodings+--+-- -----------------------------------------------------------------------------++module GHC.Utils.Encoding (+        -- * UTF-8+        utf8DecodeChar#,+        utf8PrevChar,+        utf8CharStart,+        utf8DecodeChar,+        utf8DecodeByteString,+        utf8DecodeStringLazy,+        utf8EncodeChar,+        utf8EncodeString,+        utf8EncodedLength,+        countUTF8Chars,++        -- * Z-encoding+        zEncodeString,+        zDecodeString,++        -- * Base62-encoding+        toBase62,+        toBase62Padded+  ) where++import GHC.Prelude++import Foreign+import Foreign.ForeignPtr.Unsafe+import Data.Char+import qualified Data.Char as Char+import Numeric+import GHC.IO++import Data.ByteString (ByteString)+import qualified Data.ByteString.Internal as BS++import GHC.Exts++-- -----------------------------------------------------------------------------+-- UTF-8++-- We can't write the decoder as efficiently as we'd like without+-- resorting to unboxed extensions, unfortunately.  I tried to write+-- an IO version of this function, but GHC can't eliminate boxed+-- results from an IO-returning function.+--+-- We assume we can ignore overflow when parsing a multibyte character here.+-- To make this safe, we add extra sentinel bytes to unparsed UTF-8 sequences+-- before decoding them (see StringBuffer.hs).++{-# INLINE utf8DecodeChar# #-}+utf8DecodeChar# :: Addr# -> (# Char#, Int# #)+utf8DecodeChar# a# =+  let !ch0 = word2Int# (indexWord8OffAddr# a# 0#) in+  case () of+    _ | isTrue# (ch0 <=# 0x7F#) -> (# chr# ch0, 1# #)++      | isTrue# ((ch0 >=# 0xC0#) `andI#` (ch0 <=# 0xDF#)) ->+        let !ch1 = word2Int# (indexWord8OffAddr# a# 1#) in+        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else+        (# chr# (((ch0 -# 0xC0#) `uncheckedIShiftL#` 6#) +#+                  (ch1 -# 0x80#)),+           2# #)++      | isTrue# ((ch0 >=# 0xE0#) `andI#` (ch0 <=# 0xEF#)) ->+        let !ch1 = word2Int# (indexWord8OffAddr# a# 1#) in+        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else+        let !ch2 = word2Int# (indexWord8OffAddr# a# 2#) in+        if isTrue# ((ch2 <# 0x80#) `orI#` (ch2 >=# 0xC0#)) then fail 2# else+        (# chr# (((ch0 -# 0xE0#) `uncheckedIShiftL#` 12#) +#+                 ((ch1 -# 0x80#) `uncheckedIShiftL#` 6#)  +#+                  (ch2 -# 0x80#)),+           3# #)++     | isTrue# ((ch0 >=# 0xF0#) `andI#` (ch0 <=# 0xF8#)) ->+        let !ch1 = word2Int# (indexWord8OffAddr# a# 1#) in+        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else+        let !ch2 = word2Int# (indexWord8OffAddr# a# 2#) in+        if isTrue# ((ch2 <# 0x80#) `orI#` (ch2 >=# 0xC0#)) then fail 2# else+        let !ch3 = word2Int# (indexWord8OffAddr# a# 3#) in+        if isTrue# ((ch3 <# 0x80#) `orI#` (ch3 >=# 0xC0#)) then fail 3# else+        (# chr# (((ch0 -# 0xF0#) `uncheckedIShiftL#` 18#) +#+                 ((ch1 -# 0x80#) `uncheckedIShiftL#` 12#) +#+                 ((ch2 -# 0x80#) `uncheckedIShiftL#` 6#)  +#+                  (ch3 -# 0x80#)),+           4# #)++      | otherwise -> fail 1#+  where+        -- all invalid sequences end up here:+        fail :: Int# -> (# Char#, Int# #)+        fail nBytes# = (# '\0'#, nBytes# #)+        -- '\xFFFD' would be the usual replacement character, but+        -- that's a valid symbol in Haskell, so will result in a+        -- confusing parse error later on.  Instead we use '\0' which+        -- will signal a lexer error immediately.++utf8DecodeChar :: Ptr Word8 -> (Char, Int)+utf8DecodeChar (Ptr a#) =+  case utf8DecodeChar# a# of (# c#, nBytes# #) -> ( C# c#, I# nBytes# )++-- UTF-8 is cleverly designed so that we can always figure out where+-- the start of the current character is, given any position in a+-- stream.  This function finds the start of the previous character,+-- assuming there *is* a previous character.+utf8PrevChar :: Ptr Word8 -> IO (Ptr Word8)+utf8PrevChar p = utf8CharStart (p `plusPtr` (-1))++utf8CharStart :: Ptr Word8 -> IO (Ptr Word8)+utf8CharStart p = go p+ where go p = do w <- peek p+                 if w >= 0x80 && w < 0xC0+                        then go (p `plusPtr` (-1))+                        else return p++utf8DecodeByteString :: ByteString -> [Char]+utf8DecodeByteString (BS.PS ptr offset len)+  = utf8DecodeStringLazy ptr offset len++utf8DecodeStringLazy :: ForeignPtr Word8 -> Int -> Int -> [Char]+utf8DecodeStringLazy fptr offset len+  = unsafeDupablePerformIO $ unpack start+  where+    !start = unsafeForeignPtrToPtr fptr `plusPtr` offset+    !end = start `plusPtr` len++    unpack p+        | p >= end  = touchForeignPtr fptr >> return []+        | otherwise =+            case utf8DecodeChar# (unPtr p) of+                (# c#, nBytes# #) -> do+                  rest <- unsafeDupableInterleaveIO $ unpack (p `plusPtr#` nBytes#)+                  return (C# c# : rest)++countUTF8Chars :: Ptr Word8 -> Int -> IO Int+countUTF8Chars ptr len = go ptr 0+  where+        !end = ptr `plusPtr` len++        go p !n+           | p >= end = return n+           | otherwise  = do+                case utf8DecodeChar# (unPtr p) of+                  (# _, nBytes# #) -> go (p `plusPtr#` nBytes#) (n+1)++unPtr :: Ptr a -> Addr#+unPtr (Ptr a) = a++plusPtr# :: Ptr a -> Int# -> Ptr a+plusPtr# ptr nBytes# = ptr `plusPtr` (I# nBytes#)++utf8EncodeChar :: Char -> Ptr Word8 -> IO (Ptr Word8)+utf8EncodeChar c ptr =+  let x = ord c in+  case () of+    _ | x > 0 && x <= 0x007f -> do+          poke ptr (fromIntegral x)+          return (ptr `plusPtr` 1)+        -- NB. '\0' is encoded as '\xC0\x80', not '\0'.  This is so that we+        -- can have 0-terminated UTF-8 strings (see GHC.Base.unpackCStringUtf8).+      | x <= 0x07ff -> do+          poke ptr (fromIntegral (0xC0 .|. ((x `shiftR` 6) .&. 0x1F)))+          pokeElemOff ptr 1 (fromIntegral (0x80 .|. (x .&. 0x3F)))+          return (ptr `plusPtr` 2)+      | x <= 0xffff -> do+          poke ptr (fromIntegral (0xE0 .|. (x `shiftR` 12) .&. 0x0F))+          pokeElemOff ptr 1 (fromIntegral (0x80 .|. (x `shiftR` 6) .&. 0x3F))+          pokeElemOff ptr 2 (fromIntegral (0x80 .|. (x .&. 0x3F)))+          return (ptr `plusPtr` 3)+      | otherwise -> do+          poke ptr (fromIntegral (0xF0 .|. (x `shiftR` 18)))+          pokeElemOff ptr 1 (fromIntegral (0x80 .|. ((x `shiftR` 12) .&. 0x3F)))+          pokeElemOff ptr 2 (fromIntegral (0x80 .|. ((x `shiftR` 6) .&. 0x3F)))+          pokeElemOff ptr 3 (fromIntegral (0x80 .|. (x .&. 0x3F)))+          return (ptr `plusPtr` 4)++utf8EncodeString :: Ptr Word8 -> String -> IO ()+utf8EncodeString ptr str = go ptr str+  where go !_   []     = return ()+        go ptr (c:cs) = do+          ptr' <- utf8EncodeChar c ptr+          go ptr' cs++utf8EncodedLength :: String -> Int+utf8EncodedLength str = go 0 str+  where go !n [] = n+        go n (c:cs)+          | ord c > 0 && ord c <= 0x007f = go (n+1) cs+          | ord c <= 0x07ff = go (n+2) cs+          | ord c <= 0xffff = go (n+3) cs+          | otherwise       = go (n+4) cs++-- -----------------------------------------------------------------------------+-- The Z-encoding++{-+This is the main name-encoding and decoding function.  It encodes any+string into a string that is acceptable as a C name.  This is done+right before we emit a symbol name into the compiled C or asm code.+Z-encoding of strings is cached in the FastString interface, so we+never encode the same string more than once.++The basic encoding scheme is this.++* Tuples (,,,) are coded as Z3T++* Alphabetic characters (upper and lower) and digits+        all translate to themselves;+        except 'Z', which translates to 'ZZ'+        and    'z', which translates to 'zz'+  We need both so that we can preserve the variable/tycon distinction++* Most other printable characters translate to 'zx' or 'Zx' for some+        alphabetic character x++* The others translate as 'znnnU' where 'nnn' is the decimal number+        of the character++        Before          After+        --------------------------+        Trak            Trak+        foo_wib         foozuwib+        >               zg+        >1              zg1+        foo#            foozh+        foo##           foozhzh+        foo##1          foozhzh1+        fooZ            fooZZ+        :+              ZCzp+        ()              Z0T     0-tuple+        (,,,,)          Z5T     5-tuple+        (# #)           Z1H     unboxed 1-tuple (note the space)+        (#,,,,#)        Z5H     unboxed 5-tuple+                (NB: There is no Z1T nor Z0H.)+-}++type UserString = String        -- As the user typed it+type EncodedString = String     -- Encoded form+++zEncodeString :: UserString -> EncodedString+zEncodeString cs = case maybe_tuple cs of+                Just n  -> n            -- Tuples go to Z2T etc+                Nothing -> go cs+          where+                go []     = []+                go (c:cs) = encode_digit_ch c ++ go' cs+                go' []     = []+                go' (c:cs) = encode_ch c ++ go' cs++unencodedChar :: Char -> Bool   -- True for chars that don't need encoding+unencodedChar 'Z' = False+unencodedChar 'z' = False+unencodedChar c   =  c >= 'a' && c <= 'z'+                  || c >= 'A' && c <= 'Z'+                  || c >= '0' && c <= '9'++-- If a digit is at the start of a symbol then we need to encode it.+-- Otherwise package names like 9pH-0.1 give linker errors.+encode_digit_ch :: Char -> EncodedString+encode_digit_ch c | c >= '0' && c <= '9' = encode_as_unicode_char c+encode_digit_ch c | otherwise            = encode_ch c++encode_ch :: Char -> EncodedString+encode_ch c | unencodedChar c = [c]     -- Common case first++-- Constructors+encode_ch '('  = "ZL"   -- Needed for things like (,), and (->)+encode_ch ')'  = "ZR"   -- For symmetry with (+encode_ch '['  = "ZM"+encode_ch ']'  = "ZN"+encode_ch ':'  = "ZC"+encode_ch 'Z'  = "ZZ"++-- Variables+encode_ch 'z'  = "zz"+encode_ch '&'  = "za"+encode_ch '|'  = "zb"+encode_ch '^'  = "zc"+encode_ch '$'  = "zd"+encode_ch '='  = "ze"+encode_ch '>'  = "zg"+encode_ch '#'  = "zh"+encode_ch '.'  = "zi"+encode_ch '<'  = "zl"+encode_ch '-'  = "zm"+encode_ch '!'  = "zn"+encode_ch '+'  = "zp"+encode_ch '\'' = "zq"+encode_ch '\\' = "zr"+encode_ch '/'  = "zs"+encode_ch '*'  = "zt"+encode_ch '_'  = "zu"+encode_ch '%'  = "zv"+encode_ch c    = encode_as_unicode_char c++encode_as_unicode_char :: Char -> EncodedString+encode_as_unicode_char c = 'z' : if isDigit (head hex_str) then hex_str+                                                           else '0':hex_str+  where hex_str = showHex (ord c) "U"+  -- ToDo: we could improve the encoding here in various ways.+  -- eg. strings of unicode characters come out as 'z1234Uz5678U', we+  -- could remove the 'U' in the middle (the 'z' works as a separator).++zDecodeString :: EncodedString -> UserString+zDecodeString [] = []+zDecodeString ('Z' : d : rest)+  | isDigit d = decode_tuple   d rest+  | otherwise = decode_upper   d : zDecodeString rest+zDecodeString ('z' : d : rest)+  | isDigit d = decode_num_esc d rest+  | otherwise = decode_lower   d : zDecodeString rest+zDecodeString (c   : rest) = c : zDecodeString rest++decode_upper, decode_lower :: Char -> Char++decode_upper 'L' = '('+decode_upper 'R' = ')'+decode_upper 'M' = '['+decode_upper 'N' = ']'+decode_upper 'C' = ':'+decode_upper 'Z' = 'Z'+decode_upper ch  = {-pprTrace "decode_upper" (char ch)-} ch++decode_lower 'z' = 'z'+decode_lower 'a' = '&'+decode_lower 'b' = '|'+decode_lower 'c' = '^'+decode_lower 'd' = '$'+decode_lower 'e' = '='+decode_lower 'g' = '>'+decode_lower 'h' = '#'+decode_lower 'i' = '.'+decode_lower 'l' = '<'+decode_lower 'm' = '-'+decode_lower 'n' = '!'+decode_lower 'p' = '+'+decode_lower 'q' = '\''+decode_lower 'r' = '\\'+decode_lower 's' = '/'+decode_lower 't' = '*'+decode_lower 'u' = '_'+decode_lower 'v' = '%'+decode_lower ch  = {-pprTrace "decode_lower" (char ch)-} ch++-- Characters not having a specific code are coded as z224U (in hex)+decode_num_esc :: Char -> EncodedString -> UserString+decode_num_esc d rest+  = go (digitToInt d) rest+  where+    go n (c : rest) | isHexDigit c = go (16*n + digitToInt c) rest+    go n ('U' : rest)           = chr n : zDecodeString rest+    go n other = error ("decode_num_esc: " ++ show n ++  ' ':other)++decode_tuple :: Char -> EncodedString -> UserString+decode_tuple d rest+  = go (digitToInt d) rest+  where+        -- NB. recurse back to zDecodeString after decoding the tuple, because+        -- the tuple might be embedded in a longer name.+    go n (c : rest) | isDigit c = go (10*n + digitToInt c) rest+    go 0 ('T':rest)     = "()" ++ zDecodeString rest+    go n ('T':rest)     = '(' : replicate (n-1) ',' ++ ")" ++ zDecodeString rest+    go 1 ('H':rest)     = "(# #)" ++ zDecodeString rest+    go n ('H':rest)     = '(' : '#' : replicate (n-1) ',' ++ "#)" ++ zDecodeString rest+    go n other = error ("decode_tuple: " ++ show n ++ ' ':other)++{-+Tuples are encoded as+        Z3T or Z3H+for 3-tuples or unboxed 3-tuples respectively.  No other encoding starts+        Z<digit>++* "(# #)" is the tycon for an unboxed 1-tuple (not 0-tuple)+  There are no unboxed 0-tuples.++* "()" is the tycon for a boxed 0-tuple.+  There are no boxed 1-tuples.+-}++maybe_tuple :: UserString -> Maybe EncodedString++maybe_tuple "(# #)" = Just("Z1H")+maybe_tuple ('(' : '#' : cs) = case count_commas (0::Int) cs of+                                 (n, '#' : ')' : _) -> Just ('Z' : shows (n+1) "H")+                                 _                  -> Nothing+maybe_tuple "()" = Just("Z0T")+maybe_tuple ('(' : cs)       = case count_commas (0::Int) cs of+                                 (n, ')' : _) -> Just ('Z' : shows (n+1) "T")+                                 _            -> Nothing+maybe_tuple _                = Nothing++count_commas :: Int -> String -> (Int, String)+count_commas n (',' : cs) = count_commas (n+1) cs+count_commas n cs         = (n,cs)+++{-+************************************************************************+*                                                                      *+                        Base 62+*                                                                      *+************************************************************************++Note [Base 62 encoding 128-bit integers]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Instead of base-62 encoding a single 128-bit integer+(ceil(21.49) characters), we'll base-62 a pair of 64-bit integers+(2 * ceil(10.75) characters).  Luckily for us, it's the same number of+characters!+-}++--------------------------------------------------------------------------+-- Base 62++-- The base-62 code is based off of 'locators'+-- ((c) Operational Dynamics Consulting, BSD3 licensed)++-- | Size of a 64-bit word when written as a base-62 string+word64Base62Len :: Int+word64Base62Len = 11++-- | Converts a 64-bit word into a base-62 string+toBase62Padded :: Word64 -> String+toBase62Padded w = pad ++ str+  where+    pad = replicate len '0'+    len = word64Base62Len - length str -- 11 == ceil(64 / lg 62)+    str = toBase62 w++toBase62 :: Word64 -> String+toBase62 w = showIntAtBase 62 represent w ""+  where+    represent :: Int -> Char+    represent x+        | x < 10 = Char.chr (48 + x)+        | x < 36 = Char.chr (65 + x - 10)+        | x < 62 = Char.chr (97 + x - 36)+        | otherwise = error "represent (base 62): impossible!"
+ compiler/GHC/Utils/Error.hs view
@@ -0,0 +1,976 @@+{-+(c) The AQUA Project, Glasgow University, 1994-1998++\section[ErrsUtils]{Utilities for error reporting}+-}++{-# LANGUAGE CPP #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE LambdaCase #-}++module GHC.Utils.Error (+        -- * Basic types+        Validity(..), andValid, allValid, isValid, getInvalids, orValid,+        Severity(..),++        -- * Messages+        ErrMsg, errMsgDoc, errMsgSeverity, errMsgReason,+        ErrDoc, errDoc, errDocImportant, errDocContext, errDocSupplementary,+        WarnMsg, MsgDoc,+        Messages, ErrorMessages, WarningMessages,+        unionMessages,+        errMsgSpan, errMsgContext,+        errorsFound, isEmptyMessages,+        isWarnMsgFatal,+        warningsToMessages,++        -- ** Formatting+        pprMessageBag, pprErrMsgBagWithLoc,+        pprLocErrMsg, printBagOfErrors,+        formatErrDoc,++        -- ** Construction+        emptyMessages, mkLocMessage, mkLocMessageAnn, makeIntoWarning,+        mkErrMsg, mkPlainErrMsg, mkErrDoc, mkLongErrMsg, mkWarnMsg,+        mkPlainWarnMsg,+        mkLongWarnMsg,++        -- * Utilities+        doIfSet, doIfSet_dyn,+        getCaretDiagnostic,++        -- * Dump files+        dumpIfSet, dumpIfSet_dyn, dumpIfSet_dyn_printer,+        dumpOptionsFromFlag, DumpOptions (..),+        DumpFormat (..), DumpAction, dumpAction, defaultDumpAction,+        TraceAction, traceAction, defaultTraceAction,+        touchDumpFile,++        -- * Issuing messages during compilation+        putMsg, printInfoForUser, printOutputForUser,+        logInfo, logOutput,+        errorMsg, warningMsg,+        fatalErrorMsg, fatalErrorMsg'',+        compilationProgressMsg,+        showPass,+        withTiming, withTimingSilent, withTimingD, withTimingSilentD,+        debugTraceMsg,+        ghcExit,+        prettyPrintGhcErrors,+        traceCmd+    ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Data.Bag+import GHC.Utils.Exception+import GHC.Utils.Outputable as Outputable+import GHC.Utils.Panic+import qualified GHC.Utils.Ppr.Colour as Col+import GHC.Types.SrcLoc as SrcLoc+import GHC.Driver.Session+import GHC.Data.FastString (unpackFS)+import GHC.Data.StringBuffer (atLine, hGetStringBuffer, len, lexemeToString)+import GHC.Utils.Json++import System.Directory+import System.Exit      ( ExitCode(..), exitWith )+import System.FilePath  ( takeDirectory, (</>) )+import Data.List+import qualified Data.Set as Set+import Data.IORef+import Data.Maybe       ( fromMaybe )+import Data.Function+import Data.Time+import Debug.Trace+import Control.Monad+import Control.Monad.IO.Class+import System.IO+import System.IO.Error  ( catchIOError )+import GHC.Conc         ( getAllocationCounter )+import System.CPUTime++-------------------------+type MsgDoc  = SDoc++-------------------------+data Validity+  = IsValid            -- ^ Everything is fine+  | NotValid MsgDoc    -- ^ A problem, and some indication of why++isValid :: Validity -> Bool+isValid IsValid       = True+isValid (NotValid {}) = False++andValid :: Validity -> Validity -> Validity+andValid IsValid v = v+andValid v _       = v++-- | If they aren't all valid, return the first+allValid :: [Validity] -> Validity+allValid []       = IsValid+allValid (v : vs) = v `andValid` allValid vs++getInvalids :: [Validity] -> [MsgDoc]+getInvalids vs = [d | NotValid d <- vs]++orValid :: Validity -> Validity -> Validity+orValid IsValid _ = IsValid+orValid _       v = v++-- -----------------------------------------------------------------------------+-- Basic error messages: just render a message with a source location.++type Messages        = (WarningMessages, ErrorMessages)+type WarningMessages = Bag WarnMsg+type ErrorMessages   = Bag ErrMsg++unionMessages :: Messages -> Messages -> Messages+unionMessages (warns1, errs1) (warns2, errs2) =+  (warns1 `unionBags` warns2, errs1 `unionBags` errs2)++data ErrMsg = ErrMsg {+        errMsgSpan        :: SrcSpan,+        errMsgContext     :: PrintUnqualified,+        errMsgDoc         :: ErrDoc,+        -- | This has the same text as errDocImportant . errMsgDoc.+        errMsgShortString :: String,+        errMsgSeverity    :: Severity,+        errMsgReason      :: WarnReason+        }+        -- The SrcSpan is used for sorting errors into line-number order+++-- | Categorise error msgs by their importance.  This is so each section can+-- be rendered visually distinct.  See Note [Error report] for where these come+-- from.+data ErrDoc = ErrDoc {+        -- | Primary error msg.+        errDocImportant     :: [MsgDoc],+        -- | Context e.g. \"In the second argument of ...\".+        errDocContext       :: [MsgDoc],+        -- | Supplementary information, e.g. \"Relevant bindings include ...\".+        errDocSupplementary :: [MsgDoc]+        }++errDoc :: [MsgDoc] -> [MsgDoc] -> [MsgDoc] -> ErrDoc+errDoc = ErrDoc++type WarnMsg = ErrMsg++data Severity+  = SevOutput+  | SevFatal+  | SevInteractive++  | SevDump+    -- ^ Log message intended for compiler developers+    -- No file/line/column stuff++  | SevInfo+    -- ^ Log messages intended for end users.+    -- No file/line/column stuff.++  | SevWarning+  | SevError+    -- ^ SevWarning and SevError are used for warnings and errors+    --   o The message has a file/line/column heading,+    --     plus "warning:" or "error:",+    --     added by mkLocMessags+    --   o Output is intended for end users+  deriving Show+++instance ToJson Severity where+  json s = JSString (show s)+++instance Show ErrMsg where+    show em = errMsgShortString em++pprMessageBag :: Bag MsgDoc -> SDoc+pprMessageBag msgs = vcat (punctuate blankLine (bagToList msgs))++-- | Make an unannotated error message with location info.+mkLocMessage :: Severity -> SrcSpan -> MsgDoc -> MsgDoc+mkLocMessage = mkLocMessageAnn Nothing++-- | Make a possibly annotated error message with location info.+mkLocMessageAnn+  :: Maybe String                       -- ^ optional annotation+  -> Severity                           -- ^ severity+  -> SrcSpan                            -- ^ location+  -> MsgDoc                             -- ^ message+  -> MsgDoc+  -- Always print the location, even if it is unhelpful.  Error messages+  -- 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+    = sdocOption sdocColScheme $ \col_scheme ->+      let locn' = sdocOption sdocErrorSpans $ \case+                     True  -> ppr locn+                     False -> ppr (srcSpanStart locn)++          sevColour = getSeverityColour severity col_scheme++          -- Add optional information+          optAnn = case ann of+            Nothing -> text ""+            Just i  -> text " [" <> coloured sevColour (text i) <> text "]"++          -- Add prefixes, like    Foo.hs:34: warning:+          --                           <the warning message>+          header = locn' <> colon <+>+                   coloured sevColour sevText <> optAnn++      in coloured (Col.sMessage col_scheme)+                  (hang (coloured (Col.sHeader col_scheme) header) 4+                        msg)++  where+    sevText =+      case severity of+        SevWarning -> text "warning:"+        SevError   -> text "error:"+        SevFatal   -> text "fatal:"+        _          -> empty++getSeverityColour :: Severity -> Col.Scheme -> Col.PprColour+getSeverityColour SevWarning = Col.sWarning+getSeverityColour SevError   = Col.sError+getSeverityColour SevFatal   = Col.sFatal+getSeverityColour _          = const mempty++getCaretDiagnostic :: Severity -> SrcSpan -> IO MsgDoc+getCaretDiagnostic _ (UnhelpfulSpan _) = pure empty+getCaretDiagnostic severity (RealSrcSpan span _) = do+  caretDiagnostic <$> getSrcLine (srcSpanFile span) row++  where+    getSrcLine fn i =+      getLine i (unpackFS fn)+        `catchIOError` \_ ->+          pure Nothing++    getLine i fn = do+      -- StringBuffer has advantages over readFile:+      -- (a) no lazy IO, otherwise IO exceptions may occur in pure code+      -- (b) always UTF-8, rather than some system-dependent encoding+      --     (Haskell source code must be UTF-8 anyway)+      content <- hGetStringBuffer fn+      case atLine i content of+        Just at_line -> pure $+          case lines (fix <$> lexemeToString at_line (len at_line)) of+            srcLine : _ -> Just srcLine+            _           -> Nothing+        _ -> pure Nothing++    -- allow user to visibly see that their code is incorrectly encoded+    -- (StringBuffer.nextChar uses \0 to represent undecodable characters)+    fix '\0' = '\xfffd'+    fix c    = c++    row = srcSpanStartLine span+    rowStr = show row+    multiline = row /= srcSpanEndLine span++    caretDiagnostic Nothing = empty+    caretDiagnostic (Just srcLineWithNewline) =+      sdocOption sdocColScheme$ \col_scheme ->+      let sevColour = getSeverityColour severity col_scheme+          marginColour = Col.sMargin col_scheme+      in+      coloured marginColour (text marginSpace) <>+      text ("\n") <>+      coloured marginColour (text marginRow) <>+      text (" " ++ srcLinePre) <>+      coloured sevColour (text srcLineSpan) <>+      text (srcLinePost ++ "\n") <>+      coloured marginColour (text marginSpace) <>+      coloured sevColour (text (" " ++ caretLine))++      where++        -- expand tabs in a device-independent manner #13664+        expandTabs tabWidth i s =+          case s of+            ""        -> ""+            '\t' : cs -> replicate effectiveWidth ' ' +++                         expandTabs tabWidth (i + effectiveWidth) cs+            c    : cs -> c : expandTabs tabWidth (i + 1) cs+          where effectiveWidth = tabWidth - i `mod` tabWidth++        srcLine = filter (/= '\n') (expandTabs 8 0 srcLineWithNewline)++        start = srcSpanStartCol span - 1+        end | multiline = length srcLine+            | otherwise = srcSpanEndCol span - 1+        width = max 1 (end - start)++        marginWidth = length rowStr+        marginSpace = replicate marginWidth ' ' ++ " |"+        marginRow   = rowStr ++ " |"++        (srcLinePre,  srcLineRest) = splitAt start srcLine+        (srcLineSpan, srcLinePost) = splitAt width srcLineRest++        caretEllipsis | multiline = "..."+                      | otherwise = ""+        caretLine = replicate start ' ' ++ replicate width '^' ++ caretEllipsis++makeIntoWarning :: WarnReason -> ErrMsg -> ErrMsg+makeIntoWarning reason err = err+    { errMsgSeverity = SevWarning+    , errMsgReason = reason }++-- -----------------------------------------------------------------------------+-- Collecting up messages for later ordering and printing.++mk_err_msg :: DynFlags -> Severity -> SrcSpan -> PrintUnqualified -> ErrDoc -> ErrMsg+mk_err_msg dflags sev locn print_unqual doc+ = ErrMsg { errMsgSpan = locn+          , errMsgContext = print_unqual+          , errMsgDoc = doc+          , errMsgShortString = showSDoc dflags (vcat (errDocImportant doc))+          , errMsgSeverity = sev+          , errMsgReason = NoReason }++mkErrDoc :: DynFlags -> SrcSpan -> PrintUnqualified -> ErrDoc -> ErrMsg+mkErrDoc dflags = mk_err_msg dflags SevError++mkLongErrMsg, mkLongWarnMsg   :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> MsgDoc -> ErrMsg+-- ^ A long (multi-line) error message+mkErrMsg, mkWarnMsg           :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc            -> ErrMsg+-- ^ A short (one-line) error message+mkPlainErrMsg, mkPlainWarnMsg :: DynFlags -> SrcSpan ->                     MsgDoc            -> ErrMsg+-- ^ Variant that doesn't care about qualified/unqualified names++mkLongErrMsg   dflags locn unqual msg extra = mk_err_msg dflags SevError   locn unqual        (ErrDoc [msg] [] [extra])+mkErrMsg       dflags locn unqual msg       = mk_err_msg dflags SevError   locn unqual        (ErrDoc [msg] [] [])+mkPlainErrMsg  dflags locn        msg       = mk_err_msg dflags SevError   locn alwaysQualify (ErrDoc [msg] [] [])+mkLongWarnMsg  dflags locn unqual msg extra = mk_err_msg dflags SevWarning locn unqual        (ErrDoc [msg] [] [extra])+mkWarnMsg      dflags locn unqual msg       = mk_err_msg dflags SevWarning locn unqual        (ErrDoc [msg] [] [])+mkPlainWarnMsg dflags locn        msg       = mk_err_msg dflags SevWarning locn alwaysQualify (ErrDoc [msg] [] [])++----------------+emptyMessages :: Messages+emptyMessages = (emptyBag, emptyBag)++isEmptyMessages :: Messages -> Bool+isEmptyMessages (warns, errs) = isEmptyBag warns && isEmptyBag errs++errorsFound :: DynFlags -> Messages -> Bool+errorsFound _dflags (_warns, errs) = not (isEmptyBag errs)++warningsToMessages :: DynFlags -> WarningMessages -> Messages+warningsToMessages dflags =+  partitionBagWith $ \warn ->+    case isWarnMsgFatal dflags warn of+      Nothing -> Left warn+      Just err_reason ->+        Right warn{ errMsgSeverity = SevError+                  , errMsgReason = ErrReason err_reason }++printBagOfErrors :: DynFlags -> Bag ErrMsg -> IO ()+printBagOfErrors dflags bag_of_errors+  = sequence_ [ let style = mkErrStyle dflags unqual+                    ctx   = initSDocContext dflags style+                in putLogMsg dflags reason sev s style (formatErrDoc ctx doc)+              | ErrMsg { errMsgSpan      = s,+                         errMsgDoc       = doc,+                         errMsgSeverity  = sev,+                         errMsgReason    = reason,+                         errMsgContext   = unqual } <- sortMsgBag (Just dflags)+                                                                  bag_of_errors ]++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 ctx))+        [important, context, supplementary]+    starred = (bullet<+>) . vcat++pprErrMsgBagWithLoc :: Bag ErrMsg -> [SDoc]+pprErrMsgBagWithLoc bag = [ pprLocErrMsg item | item <- sortMsgBag Nothing bag ]++pprLocErrMsg :: ErrMsg -> SDoc+pprLocErrMsg (ErrMsg { errMsgSpan      = s+                     , errMsgDoc       = doc+                     , errMsgSeverity  = sev+                     , errMsgContext   = unqual })+  = sdocWithContext $ \ctx ->+    withErrStyle unqual $ mkLocMessage sev s (formatErrDoc ctx doc)++sortMsgBag :: Maybe DynFlags -> Bag ErrMsg -> [ErrMsg]+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++ghcExit :: DynFlags -> Int -> IO ()+ghcExit dflags val+  | val == 0  = exitWith ExitSuccess+  | otherwise = do errorMsg dflags (text "\nCompilation had errors\n\n")+                   exitWith (ExitFailure val)++doIfSet :: Bool -> IO () -> IO ()+doIfSet flag action | flag      = action+                    | otherwise = return ()++doIfSet_dyn :: DynFlags -> GeneralFlag -> IO () -> IO()+doIfSet_dyn dflags flag action | gopt flag dflags = action+                               | otherwise        = return ()++-- -----------------------------------------------------------------------------+-- Dumping++dumpIfSet :: DynFlags -> Bool -> String -> SDoc -> IO ()+dumpIfSet dflags flag hdr doc+  | not flag   = return ()+  | otherwise  = putLogMsg  dflags+                            NoReason+                            SevDump+                            noSrcSpan+                            (defaultDumpStyle dflags)+                            (mkDumpDoc hdr doc)++-- | a wrapper around 'dumpAction'.+-- First check whether the dump flag is set+-- Do nothing if it is unset+dumpIfSet_dyn :: DynFlags -> DumpFlag -> String -> DumpFormat -> SDoc -> IO ()+dumpIfSet_dyn = dumpIfSet_dyn_printer alwaysQualify++-- | a wrapper around 'dumpAction'.+-- First check whether the dump flag is set+-- Do nothing if it is unset+--+-- Unlike 'dumpIfSet_dyn', has a printer argument+dumpIfSet_dyn_printer :: PrintUnqualified -> DynFlags -> DumpFlag -> String+                         -> DumpFormat -> SDoc -> IO ()+dumpIfSet_dyn_printer printer dflags flag hdr fmt doc+  = when (dopt flag dflags) $ do+      let sty = mkDumpStyle dflags printer+      dumpAction dflags sty (dumpOptionsFromFlag flag) hdr fmt doc++mkDumpDoc :: String -> SDoc -> SDoc+mkDumpDoc hdr doc+   = vcat [blankLine,+           line <+> text hdr <+> line,+           doc,+           blankLine]+     where+        line = text (replicate 20 '=')+++-- | Ensure that a dump file is created even if it stays empty+touchDumpFile :: DynFlags -> DumpOptions -> IO ()+touchDumpFile dflags dumpOpt = withDumpFileHandle dflags dumpOpt (const (return ()))++-- | Run an action with the handle of a 'DumpFlag' if we are outputting to a+-- file, otherwise 'Nothing'.+withDumpFileHandle :: DynFlags -> DumpOptions -> (Maybe Handle -> IO ()) -> IO ()+withDumpFileHandle dflags dumpOpt action = do+    let mFile = chooseDumpFile dflags dumpOpt+    case mFile of+      Just fileName -> do+        let gdref = generatedDumps dflags+        gd <- readIORef gdref+        let append = Set.member fileName gd+            mode = if append then AppendMode else WriteMode+        unless append $+            writeIORef gdref (Set.insert fileName gd)+        createDirectoryIfMissing True (takeDirectory fileName)+        withFile fileName mode $ \handle -> do+            -- We do not want the dump file to be affected by+            -- environment variables, but instead to always use+            -- UTF8. See:+            -- https://gitlab.haskell.org/ghc/ghc/issues/10762+            hSetEncoding handle utf8++            action (Just handle)+      Nothing -> action Nothing+++-- | Write out a dump.+-- If --dump-to-file is set then this goes to a file.+-- otherwise emit to stdout.+--+-- When @hdr@ is empty, we print in a more compact format (no separators and+-- blank lines)+dumpSDocWithStyle :: PprStyle -> DynFlags -> DumpOptions -> String -> SDoc -> IO ()+dumpSDocWithStyle sty dflags dumpOpt hdr doc =+    withDumpFileHandle dflags dumpOpt writeDump+  where+    -- write dump to file+    writeDump (Just handle) = do+        doc' <- if null hdr+                then return doc+                else do t <- getCurrentTime+                        let timeStamp = if (gopt Opt_SuppressTimestamps dflags)+                                          then empty+                                          else text (show t)+                        let d = timeStamp+                                $$ blankLine+                                $$ doc+                        return $ mkDumpDoc hdr d+        defaultLogActionHPrintDoc dflags handle doc' sty++    -- write the dump to stdout+    writeDump Nothing = do+        let (doc', severity)+              | null hdr  = (doc, SevOutput)+              | otherwise = (mkDumpDoc hdr doc, SevDump)+        putLogMsg dflags NoReason severity noSrcSpan sty doc'+++-- | Choose where to put a dump file based on DynFlags+--+chooseDumpFile :: DynFlags -> DumpOptions -> Maybe FilePath+chooseDumpFile dflags dumpOpt++        | gopt Opt_DumpToFile dflags || dumpForcedToFile dumpOpt+        , Just prefix <- getPrefix+        = Just $ setDir (prefix ++ dumpSuffix dumpOpt)++        | otherwise+        = Nothing++        where getPrefix+                 -- dump file location is being forced+                 --      by the --ddump-file-prefix flag.+               | Just prefix <- dumpPrefixForce dflags+                  = Just prefix+                 -- 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.+               | otherwise+                  = Nothing+              setDir f = case dumpDir dflags of+                         Just d  -> d </> f+                         Nothing ->       f++-- | Dump options+--+-- Dumps are printed on stdout by default except when the `dumpForcedToFile`+-- field is set to True.+--+-- When `dumpForcedToFile` is True or when `-ddump-to-file` is set, dumps are+-- written into a file whose suffix is given in the `dumpSuffix` field.+--+data DumpOptions = DumpOptions+   { dumpForcedToFile :: Bool   -- ^ Must be dumped into a file, even if+                                --   -ddump-to-file isn't set+   , dumpSuffix       :: String -- ^ Filename suffix used when dumped into+                                --   a file+   }++-- | Create dump options from a 'DumpFlag'+dumpOptionsFromFlag :: DumpFlag -> DumpOptions+dumpOptionsFromFlag Opt_D_th_dec_file =+   DumpOptions                        -- -dth-dec-file dumps expansions of TH+      { dumpForcedToFile = True       -- splices into MODULE.th.hs even when+      , dumpSuffix       = "th.hs"    -- -ddump-to-file isn't set+      }+dumpOptionsFromFlag flag =+   DumpOptions+      { dumpForcedToFile = False+      , dumpSuffix       = suffix -- build a suffix from the flag name+      }                           -- e.g. -ddump-asm => ".dump-asm"+   where+      str  = show flag+      suff = case stripPrefix "Opt_D_" str of+             Just x  -> x+             Nothing -> panic ("Bad flag name: " ++ str)+      suffix = map (\c -> if c == '_' then '-' else c) suff+++-- -----------------------------------------------------------------------------+-- Outputting messages from the compiler++-- We want all messages to go through one place, so that we can+-- redirect them if necessary.  For example, when GHC is used as a+-- library we might want to catch all messages that GHC tries to+-- output and do something else with them.++ifVerbose :: DynFlags -> Int -> IO () -> IO ()+ifVerbose dflags val act+  | verbosity dflags >= val = act+  | otherwise               = return ()++errorMsg :: DynFlags -> MsgDoc -> IO ()+errorMsg dflags msg+   = putLogMsg dflags NoReason SevError noSrcSpan (defaultErrStyle dflags) msg++warningMsg :: DynFlags -> MsgDoc -> IO ()+warningMsg dflags msg+   = putLogMsg dflags NoReason SevWarning noSrcSpan (defaultErrStyle dflags) msg++fatalErrorMsg :: DynFlags -> MsgDoc -> IO ()+fatalErrorMsg dflags msg =+    putLogMsg dflags NoReason SevFatal noSrcSpan (defaultErrStyle dflags) msg++fatalErrorMsg'' :: FatalMessager -> String -> IO ()+fatalErrorMsg'' fm msg = fm msg++compilationProgressMsg :: DynFlags -> String -> IO ()+compilationProgressMsg dflags msg = do+    traceEventIO $ "GHC progress: " ++ msg+    ifVerbose dflags 1 $+        logOutput dflags (defaultUserStyle dflags) (text msg)++showPass :: DynFlags -> String -> IO ()+showPass dflags what+  = ifVerbose dflags 2 $+    logInfo dflags (defaultUserStyle dflags) (text "***" <+> text what <> colon)++data PrintTimings = PrintTimings | DontPrintTimings+  deriving (Eq, Show)++-- | Time a compilation phase.+--+-- When timings are enabled (e.g. with the @-v2@ flag), the allocations+-- and CPU time used by the phase will be reported to stderr. Consider+-- a typical usage:+-- @withTiming getDynFlags (text "simplify") force PrintTimings pass@.+-- When timings are enabled the following costs are included in the+-- produced accounting,+--+--  - The cost of executing @pass@ to a result @r@ in WHNF+--  - The cost of evaluating @force r@ to WHNF (e.g. @()@)+--+-- The choice of the @force@ function depends upon the amount of forcing+-- desired; the goal here is to ensure that the cost of evaluating the result+-- is, to the greatest extent possible, included in the accounting provided by+-- 'withTiming'. Often the pass already sufficiently forces its result during+-- construction; in this case @const ()@ is a reasonable choice.+-- In other cases, it is necessary to evaluate the result to normal form, in+-- which case something like @Control.DeepSeq.rnf@ is appropriate.+--+-- To avoid adversely affecting compiler performance when timings are not+-- requested, the result is only forced when timings are enabled.+--+-- See Note [withTiming] for more.+withTiming :: MonadIO m+           => DynFlags     -- ^ DynFlags+           -> SDoc         -- ^ The name of the phase+           -> (a -> ())    -- ^ A function to force the result+                           -- (often either @const ()@ or 'rnf')+           -> m a          -- ^ The body of the phase to be timed+           -> m a+withTiming dflags what force action =+  withTiming' dflags what force PrintTimings action++-- | Like withTiming but get DynFlags from the Monad.+withTimingD :: (MonadIO m, HasDynFlags m)+           => SDoc         -- ^ The name of the phase+           -> (a -> ())    -- ^ A function to force the result+                           -- (often either @const ()@ or 'rnf')+           -> m a          -- ^ The body of the phase to be timed+           -> m a+withTimingD what force action = do+  dflags <- getDynFlags+  withTiming' dflags what force PrintTimings action+++-- | Same as 'withTiming', but doesn't print timings in the+--   console (when given @-vN@, @N >= 2@ or @-ddump-timings@).+--+--   See Note [withTiming] for more.+withTimingSilent+  :: MonadIO m+  => DynFlags   -- ^ DynFlags+  -> SDoc       -- ^ The name of the phase+  -> (a -> ())  -- ^ A function to force the result+                -- (often either @const ()@ or 'rnf')+  -> m a        -- ^ The body of the phase to be timed+  -> m a+withTimingSilent dflags what force action =+  withTiming' dflags what force DontPrintTimings action++-- | Same as 'withTiming', but doesn't print timings in the+--   console (when given @-vN@, @N >= 2@ or @-ddump-timings@)+--   and gets the DynFlags from the given Monad.+--+--   See Note [withTiming] for more.+withTimingSilentD+  :: (MonadIO m, HasDynFlags m)+  => SDoc       -- ^ The name of the phase+  -> (a -> ())  -- ^ A function to force the result+                -- (often either @const ()@ or 'rnf')+  -> m a        -- ^ The body of the phase to be timed+  -> m a+withTimingSilentD what force action = do+  dflags <- getDynFlags+  withTiming' dflags what force DontPrintTimings action++-- | Worker for 'withTiming' and 'withTimingSilent'.+withTiming' :: MonadIO m+            => DynFlags   -- ^ A means of getting a 'DynFlags' (often+                            -- 'getDynFlags' will work here)+            -> SDoc         -- ^ The name of the phase+            -> (a -> ())    -- ^ A function to force the result+                            -- (often either @const ()@ or 'rnf')+            -> PrintTimings -- ^ Whether to print the timings+            -> m a          -- ^ The body of the phase to be timed+            -> m a+withTiming' dflags what force_result prtimings action+  = do if verbosity dflags >= 2 || dopt Opt_D_dump_timings dflags+          then do whenPrintTimings $+                    logInfo dflags (defaultUserStyle dflags) $+                      text "***" <+> what <> colon+                  let ctx = initDefaultSDocContext dflags+                  eventBegins ctx what+                  alloc0 <- liftIO getAllocationCounter+                  start <- liftIO getCPUTime+                  !r <- action+                  () <- pure $ force_result r+                  eventEnds ctx what+                  end <- liftIO getCPUTime+                  alloc1 <- liftIO getAllocationCounter+                  -- recall that allocation counter counts down+                  let alloc = alloc0 - alloc1+                      time = realToFrac (end - start) * 1e-9++                  when (verbosity dflags >= 2 && prtimings == PrintTimings)+                      $ liftIO $ logInfo dflags (defaultUserStyle dflags)+                          (text "!!!" <+> what <> colon <+> text "finished in"+                           <+> doublePrec 2 time+                           <+> text "milliseconds"+                           <> comma+                           <+> text "allocated"+                           <+> doublePrec 3 (realToFrac alloc / 1024 / 1024)+                           <+> text "megabytes")++                  whenPrintTimings $+                      dumpIfSet_dyn dflags Opt_D_dump_timings "" FormatText+                          $ text $ showSDocOneLine ctx+                          $ hsep [ what <> colon+                                 , text "alloc=" <> ppr alloc+                                 , text "time=" <> doublePrec 3 time+                                 ]+                  pure r+           else action++    where whenPrintTimings = liftIO . when (prtimings == PrintTimings)+          eventBegins ctx w = do+            whenPrintTimings $ traceMarkerIO (eventBeginsDoc ctx w)+            liftIO $ traceEventIO (eventBeginsDoc ctx w)+          eventEnds ctx w = do+            whenPrintTimings $ traceMarkerIO (eventEndsDoc ctx w)+            liftIO $ traceEventIO (eventEndsDoc ctx w)++          eventBeginsDoc ctx w = showSDocOneLine ctx $ text "GHC:started:" <+> w+          eventEndsDoc   ctx w = showSDocOneLine ctx $ text "GHC:finished:" <+> w++debugTraceMsg :: DynFlags -> Int -> MsgDoc -> IO ()+debugTraceMsg dflags val msg = ifVerbose dflags val $+                               logInfo dflags (defaultDumpStyle dflags) msg+putMsg :: DynFlags -> MsgDoc -> IO ()+putMsg dflags msg = logInfo dflags (defaultUserStyle dflags) msg++printInfoForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()+printInfoForUser dflags print_unqual msg+  = logInfo dflags (mkUserStyle dflags print_unqual AllTheWay) msg++printOutputForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()+printOutputForUser dflags print_unqual msg+  = logOutput dflags (mkUserStyle dflags print_unqual AllTheWay) msg++logInfo :: DynFlags -> PprStyle -> MsgDoc -> IO ()+logInfo dflags sty msg+  = putLogMsg dflags NoReason SevInfo noSrcSpan sty msg++logOutput :: DynFlags -> PprStyle -> MsgDoc -> IO ()+-- ^ Like 'logInfo' but with 'SevOutput' rather then 'SevInfo'+logOutput dflags sty msg+  = putLogMsg dflags NoReason SevOutput noSrcSpan sty msg++prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a+prettyPrintGhcErrors dflags+    = ghandle $ \e -> case e of+                      PprPanic str doc ->+                          pprDebugAndThen dflags panic (text str) doc+                      PprSorry str doc ->+                          pprDebugAndThen dflags sorry (text str) doc+                      PprProgramError str doc ->+                          pprDebugAndThen dflags pgmError (text str) doc+                      _ ->+                          liftIO $ throwIO e++-- | Checks if given 'WarnMsg' is a fatal warning.+isWarnMsgFatal :: DynFlags -> WarnMsg -> Maybe (Maybe WarningFlag)+isWarnMsgFatal dflags ErrMsg{errMsgReason = Reason wflag}+  = if wopt_fatal wflag dflags+      then Just (Just wflag)+      else Nothing+isWarnMsgFatal dflags _+  = if gopt Opt_WarnIsError dflags+      then Just Nothing+      else Nothing++traceCmd :: DynFlags -> String -> String -> IO a -> IO a+-- trace the command (at two levels of verbosity)+traceCmd dflags phase_name cmd_line action+ = do   { let verb = verbosity dflags+        ; showPass dflags phase_name+        ; debugTraceMsg dflags 3 (text cmd_line)+        ; case flushErr dflags of+              FlushErr io -> io++           -- And run it!+        ; action `catchIO` handle_exn verb+        }+  where+    handle_exn _verb exn = do { debugTraceMsg dflags 2 (char '\n')+                              ; debugTraceMsg dflags 2+                                (text "Failed:"+                                 <+> text cmd_line+                                 <+> text (show exn))+                              ; throwGhcExceptionIO (ProgramError (show exn))}++{- Note [withTiming]+~~~~~~~~~~~~~~~~~~~~++For reference:++  withTiming+    :: MonadIO+    => m DynFlags   -- how to get the DynFlags+    -> SDoc         -- label for the computation we're timing+    -> (a -> ())    -- how to evaluate the result+    -> PrintTimings -- whether to report the timings when passed+                    -- -v2 or -ddump-timings+    -> m a          -- computation we're timing+    -> m a++withTiming lets you run an action while:++(1) measuring the CPU time it took and reporting that on stderr+    (when PrintTimings is passed),+(2) emitting start/stop events to GHC's event log, with the label+    given as an argument.++Evaluation of the result+------------------------++'withTiming' takes as an argument a function of type 'a -> ()', whose purpose is+to evaluate the result "sufficiently". A given pass might return an 'm a' for+some monad 'm' and result type 'a', but where the 'a' is complex enough+that evaluating it to WHNF barely scratches its surface and leaves many+complex and time-consuming computations unevaluated. Those would only be+forced by the next pass, and the time needed to evaluate them would be+mis-attributed to that next pass. A more appropriate function would be+one that deeply evaluates the result, so as to assign the time spent doing it+to the pass we're timing.++Note: as hinted at above, the time spent evaluating the application of the+forcing function to the result is included in the timings reported by+'withTiming'.++How we use it+-------------++We measure the time and allocations of various passes in GHC's pipeline by just+wrapping the whole pass with 'withTiming'. This also materializes by having+a label for each pass in the eventlog, where each pass is executed in one go,+during a continuous time window.++However, from STG onwards, the pipeline uses streams to emit groups of+STG/Cmm/etc declarations one at a time, and process them until we get to+assembly code generation. This means that the execution of those last few passes+is interleaved and that we cannot measure how long they take by just wrapping+the whole thing with 'withTiming'. Instead we wrap the processing of each+individual stream element, all along the codegen pipeline, using the appropriate+label for the pass to which this processing belongs. That generates a lot more+data but allows us to get fine-grained timings about all the passes and we can+easily compute totals with tools like ghc-events-analyze (see below).+++Producing an eventlog for GHC+-----------------------------++To actually produce the eventlog, you need an eventlog-capable GHC build:++  With Hadrian:+  $ hadrian/build -j "stage1.ghc-bin.ghc.link.opts += -eventlog"++  With Make:+  $ make -j GhcStage2HcOpts+=-eventlog++You can then produce an eventlog when compiling say hello.hs by simply+doing:++  If GHC was built by Hadrian:+  $ _build/stage1/bin/ghc -ddump-timings hello.hs -o hello +RTS -l++  If GHC was built with Make:+  $ inplace/bin/ghc-stage2 -ddump-timing hello.hs -o hello +RTS -l++You could alternatively use -v<N> (with N >= 2) instead of -ddump-timings,+to ask GHC to report timings (on stderr and the eventlog).++This will write the eventlog to ./ghc.eventlog in both cases. You can then+visualize it or look at the totals for each label by using ghc-events-analyze,+threadscope or any other eventlog consumer. Illustrating with+ghc-events-analyze:++  $ ghc-events-analyze --timed --timed-txt --totals \+                       --start "GHC:started:" --stop "GHC:finished:" \+                       ghc.eventlog++This produces ghc.timed.txt (all event timestamps), ghc.timed.svg (visualisation+of the execution through the various labels) and ghc.totals.txt (total time+spent in each label).++-}+++-- | Format of a dump+--+-- Dump formats are loosely defined: dumps may contain various additional+-- headers and annotations and they may be partial. 'DumpFormat' is mainly a hint+-- (e.g. for syntax highlighters).+data DumpFormat+   = FormatHaskell   -- ^ Haskell+   | FormatCore      -- ^ Core+   | FormatSTG       -- ^ STG+   | FormatByteCode  -- ^ ByteCode+   | FormatCMM       -- ^ Cmm+   | FormatASM       -- ^ Assembly code+   | FormatC         -- ^ C code/header+   | FormatLLVM      -- ^ LLVM bytecode+   | FormatText      -- ^ Unstructured dump+   deriving (Show,Eq)++type DumpAction = DynFlags -> PprStyle -> DumpOptions -> String+                  -> DumpFormat -> SDoc -> IO ()++type TraceAction = forall a. DynFlags -> String -> SDoc -> a -> a++-- | Default action for 'dumpAction' hook+defaultDumpAction :: DumpAction+defaultDumpAction dflags sty dumpOpt title _fmt doc = do+   dumpSDocWithStyle sty dflags dumpOpt title doc++-- | Default action for 'traceAction' hook+defaultTraceAction :: TraceAction+defaultTraceAction dflags title doc = pprTraceWithFlags dflags title doc++-- | Helper for `dump_action`+dumpAction :: DumpAction+dumpAction dflags = dump_action dflags dflags++-- | Helper for `trace_action`+traceAction :: TraceAction+traceAction dflags = trace_action dflags dflags
+ compiler/GHC/Utils/Error.hs-boot view
@@ -0,0 +1,50 @@+{-# LANGUAGE RankNTypes #-}++module GHC.Utils.Error where++import GHC.Prelude+import GHC.Utils.Outputable (SDoc, PprStyle )+import GHC.Types.SrcLoc (SrcSpan)+import GHC.Utils.Json+import {-# SOURCE #-} GHC.Driver.Session ( DynFlags )++type DumpAction = DynFlags -> PprStyle -> DumpOptions -> String+                  -> DumpFormat -> SDoc -> IO ()++type TraceAction = forall a. DynFlags -> String -> SDoc -> a -> a++data DumpOptions = DumpOptions+   { dumpForcedToFile :: Bool+   , dumpSuffix       :: String+   }++data DumpFormat+  = FormatHaskell+  | FormatCore+  | FormatSTG+  | FormatByteCode+  | FormatCMM+  | FormatASM+  | FormatC+  | FormatLLVM+  | FormatText++data Severity+  = SevOutput+  | SevFatal+  | SevInteractive+  | SevDump+  | SevInfo+  | SevWarning+  | SevError+++type MsgDoc = SDoc++mkLocMessage :: Severity -> SrcSpan -> MsgDoc -> MsgDoc+mkLocMessageAnn :: Maybe String -> Severity -> SrcSpan -> MsgDoc -> MsgDoc+getCaretDiagnostic :: Severity -> SrcSpan -> IO MsgDoc+defaultDumpAction :: DumpAction+defaultTraceAction :: TraceAction++instance ToJson Severity
+ compiler/GHC/Utils/Exception.hs view
@@ -0,0 +1,83 @@+{-# OPTIONS_GHC -fno-warn-deprecations #-}+module GHC.Utils.Exception+    (+    module Control.Exception,+    module GHC.Utils.Exception+    )+    where++import GHC.Prelude++import Control.Exception+import Control.Monad.IO.Class++catchIO :: IO a -> (IOException -> IO a) -> IO a+catchIO = Control.Exception.catch++handleIO :: (IOException -> IO a) -> IO a -> IO a+handleIO = flip catchIO++tryIO :: IO a -> IO (Either IOException a)+tryIO = try++-- | A monad that can catch exceptions.  A minimal definition+-- requires a definition of 'gcatch'.+--+-- Implementations on top of 'IO' should implement 'gmask' to+-- eventually call the primitive 'Control.Exception.mask'.+-- These are used for+-- implementations that support asynchronous exceptions.  The default+-- implementations of 'gbracket' and 'gfinally' use 'gmask'+-- thus rarely require overriding.+--+class MonadIO m => ExceptionMonad m where++  -- | Generalised version of 'Control.Exception.catch', allowing an arbitrary+  -- exception handling monad instead of just 'IO'.+  gcatch :: Exception e => m a -> (e -> m a) -> m a++  -- | Generalised version of 'Control.Exception.mask_', allowing an arbitrary+  -- exception handling monad instead of just 'IO'.+  gmask :: ((m a -> m a) -> m b) -> m b++  -- | Generalised version of 'Control.Exception.bracket', allowing an arbitrary+  -- exception handling monad instead of just 'IO'.+  gbracket :: m a -> (a -> m b) -> (a -> m c) -> m c++  -- | Generalised version of 'Control.Exception.finally', allowing an arbitrary+  -- exception handling monad instead of just 'IO'.+  gfinally :: m a -> m b -> m a++  gbracket before after thing =+    gmask $ \restore -> do+      a <- before+      r <- restore (thing a) `gonException` after a+      _ <- after a+      return r++  a `gfinally` sequel =+    gmask $ \restore -> do+      r <- restore a `gonException` sequel+      _ <- sequel+      return r++instance ExceptionMonad IO where+  gcatch    = Control.Exception.catch+  gmask f   = mask (\x -> f x)++gtry :: (ExceptionMonad m, Exception e) => m a -> m (Either e a)+gtry act = gcatch (act >>= \a -> return (Right a))+                  (\e -> return (Left e))++-- | Generalised version of 'Control.Exception.handle', allowing an arbitrary+-- exception handling monad instead of just 'IO'.+ghandle :: (ExceptionMonad m, Exception e) => (e -> m a) -> m a -> m a+ghandle = flip gcatch++-- | Always executes the first argument.  If this throws an exception the+-- second argument is executed and the exception is raised again.+gonException :: (ExceptionMonad m) => m a -> m b -> m a+gonException ioA cleanup = ioA `gcatch` \e ->+                             do _ <- cleanup+                                liftIO $ throwIO (e :: SomeException)+
+ compiler/GHC/Utils/FV.hs view
@@ -0,0 +1,199 @@+{-+(c) Bartosz Nitka, Facebook 2015++-}++{-# LANGUAGE BangPatterns #-}++-- | Utilities for efficiently and deterministically computing free variables.+module GHC.Utils.FV (+        -- * Deterministic free vars computations+        FV, InterestingVarFun,++        -- * Running the computations+        fvVarList, fvVarSet, fvDVarSet,++        -- ** Manipulating those computations+        unitFV,+        emptyFV,+        mkFVs,+        unionFV,+        unionsFV,+        delFV,+        delFVs,+        filterFV,+        mapUnionFV,+    ) where++import GHC.Prelude++import GHC.Types.Var+import GHC.Types.Var.Set++-- | Predicate on possible free variables: returns @True@ iff the variable is+-- interesting+type InterestingVarFun = Var -> Bool++-- Note [Deterministic FV]+-- ~~~~~~~~~~~~~~~~~~~~~~~+-- When computing free variables, the order in which you get them affects+-- the results of floating and specialization. If you use UniqFM to collect+-- them and then turn that into a list, you get them in nondeterministic+-- order as described in Note [Deterministic UniqFM] in GHC.Types.Unique.DFM.++-- A naive algorithm for free variables relies on merging sets of variables.+-- 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+        -> 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 GHC.Types.Unique.DFM.++-- 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` That means the functions+-- returning FV need to be exported.+--+-- The conventions are:+--+-- a) non-deterministic functions:+--   * a function that returns VarSet+--       e.g. `tyVarsOfType`+-- b) deterministic functions:+--   * a worker that returns FV+--       e.g. `tyFVsOfType`+--   * a function that returns [Var]+--       e.g. `tyVarsOfTypeList`+--   * a function that returns DVarSet+--       e.g. `tyVarsOfTypeDSet`+--+-- Where tyVarsOfType, tyVarsOfTypeList, tyVarsOfTypeDSet are implemented+-- in terms of the worker evaluated with fvVarSet, fvVarList, fvDVarSet+-- respectively.++-- | Run a free variable computation, returning a list of distinct free+-- variables in deterministic order and a non-deterministic set containing+-- those variables.+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 . 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 . 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 . fvVarAcc++-- Note [FV eta expansion]+-- ~~~~~~~~~~~~~~~~~~~~~~~+-- Let's consider an eta-reduced implementation of freeVarsOf using FV:+--+-- freeVarsOf (App a b) = freeVarsOf a `unionFV` freeVarsOf b+--+-- If GHC doesn't eta-expand it, after inlining unionFV we end up with+--+-- freeVarsOf = \x ->+--   case x of+--     App a b -> \fv_cand in_scope acc ->+--       freeVarsOf a fv_cand in_scope $! freeVarsOf b fv_cand in_scope $! acc+--+-- which has to create a thunk, resulting in more allocations.+--+-- On the other hand if it is eta-expanded:+--+-- freeVarsOf (App a b) fv_cand in_scope acc =+--   (freeVarsOf a `unionFV` freeVarsOf b) fv_cand in_scope acc+--+-- after inlining unionFV we have:+--+-- freeVarsOf = \x fv_cand in_scope acc ->+--   case x of+--     App a b ->+--       freeVarsOf a fv_cand in_scope $! freeVarsOf b fv_cand in_scope $! acc+--+-- which saves allocations.+--+-- GHC when presented with knowledge about all the call sites, correctly+-- eta-expands in this case. Unfortunately due to the fact that freeVarsOf gets+-- exported to be composed with other functions, GHC doesn't have that+-- information and has to be more conservative here.+--+-- Hence functions that get exported and return FV need to be manually+-- eta-expanded. See also #11146.++-- | Add a variable - when free, to the returned free variables.+-- Ignores duplicates and respects the filtering function.+unitFV :: Id -> FV+unitFV var fv_cand in_scope acc@(have, haveSet)+  | var `elemVarSet` in_scope = acc+  | var `elemVarSet` haveSet = acc+  | fv_cand var = (var:have, extendVarSet haveSet var)+  | otherwise = acc+{-# INLINE unitFV #-}++-- | Return no free variables.+emptyFV :: FV+emptyFV _ _ acc = acc+{-# INLINE emptyFV #-}++-- | Union two free variable computations.+unionFV :: FV -> FV -> FV+unionFV fv1 fv2 fv_cand in_scope acc =+  fv1 fv_cand in_scope $! fv2 fv_cand in_scope $! acc+{-# INLINE unionFV #-}++-- | Mark the variable as not free by putting it in scope.+delFV :: Var -> FV -> FV+delFV var fv fv_cand !in_scope acc =+  fv fv_cand (extendVarSet in_scope var) acc+{-# INLINE delFV #-}++-- | Mark many free variables as not free.+delFVs :: VarSet -> FV -> FV+delFVs vars fv fv_cand !in_scope acc =+  fv fv_cand (in_scope `unionVarSet` vars) acc+{-# INLINE delFVs #-}++-- | Filter a free variable computation.+filterFV :: InterestingVarFun -> FV -> FV+filterFV fv_cand2 fv fv_cand1 in_scope acc =+  fv (\v -> fv_cand1 v && fv_cand2 v) in_scope acc+{-# INLINE filterFV #-}++-- | Map a free variable computation over a list and union the results.+mapUnionFV :: (a -> FV) -> [a] -> FV+mapUnionFV _f [] _fv_cand _in_scope acc = acc+mapUnionFV f (a:as) fv_cand in_scope acc =+  mapUnionFV f as fv_cand in_scope $! f a fv_cand in_scope $! acc+{-# INLINABLE mapUnionFV #-}++-- | Union many free variable computations.+unionsFV :: [FV] -> FV+unionsFV fvs fv_cand in_scope acc = mapUnionFV id fvs fv_cand in_scope acc+{-# INLINE unionsFV #-}++-- | Add multiple variables - when free, to the returned free variables.+-- Ignores duplicates and respects the filtering function.+mkFVs :: [Var] -> FV+mkFVs vars fv_cand in_scope acc =+  mapUnionFV unitFV vars fv_cand in_scope acc+{-# INLINE mkFVs #-}
+ compiler/GHC/Utils/Fingerprint.hs view
@@ -0,0 +1,47 @@+{-# LANGUAGE CPP #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++-- ----------------------------------------------------------------------------+--+--  (c) The University of Glasgow 2006+--+-- Fingerprints for recompilation checking and ABI versioning.+--+-- https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidance+--+-- ----------------------------------------------------------------------------++module GHC.Utils.Fingerprint (+        readHexFingerprint,+        fingerprintByteString,+        -- * Re-exported from GHC.Fingerprint+        Fingerprint(..), fingerprint0,+        fingerprintFingerprints,+        fingerprintData,+        fingerprintString,+        getFileHash+   ) where++#include "HsVersions.h"++import GHC.Prelude++import Foreign+import GHC.IO+import Numeric          ( readHex )++import qualified Data.ByteString as BS+import qualified Data.ByteString.Unsafe as BS++import GHC.Fingerprint++-- useful for parsing the output of 'md5sum', should we want to do that.+readHexFingerprint :: String -> Fingerprint+readHexFingerprint s = Fingerprint w1 w2+ where (s1,s2) = splitAt 16 s+       [(w1,"")] = readHex s1+       [(w2,"")] = readHex (take 16 s2)++fingerprintByteString :: BS.ByteString -> Fingerprint+fingerprintByteString bs = unsafeDupablePerformIO $+  BS.unsafeUseAsCStringLen bs $ \(ptr, len) -> fingerprintData (castPtr ptr) len
+ compiler/GHC/Utils/IO/Unsafe.hs view
@@ -0,0 +1,22 @@+{-+(c) The University of Glasgow, 2000-2006+-}++{-# LANGUAGE CPP, MagicHash, UnboxedTuples #-}++module GHC.Utils.IO.Unsafe+   ( inlinePerformIO,+   )+where++#include "HsVersions.h"++import GHC.Prelude ()++import GHC.Exts+import GHC.IO   (IO(..))++-- Just like unsafeDupablePerformIO, but we inline it.+{-# INLINE inlinePerformIO #-}+inlinePerformIO :: IO a -> a+inlinePerformIO (IO m) = case m realWorld# of (# _, r #)   -> r
+ compiler/GHC/Utils/Json.hs view
@@ -0,0 +1,56 @@+{-# LANGUAGE GADTs #-}+module GHC.Utils.Json where++import GHC.Prelude++import GHC.Utils.Outputable+import Data.Char+import Numeric++-- | Simple data type to represent JSON documents.+data JsonDoc where+  JSNull :: JsonDoc+  JSBool :: Bool -> JsonDoc+  JSInt  :: Int  -> JsonDoc+  JSString :: String -> JsonDoc+  JSArray :: [JsonDoc] -> JsonDoc+  JSObject :: [(String, JsonDoc)] -> JsonDoc+++-- This is simple and slow as it is only used for error reporting+renderJSON :: JsonDoc -> SDoc+renderJSON d =+  case d of+    JSNull -> text "null"+    JSBool b -> text $ if b then "true" else "false"+    JSInt    n -> ppr n+    JSString s -> doubleQuotes $ text $ escapeJsonString s+    JSArray as -> brackets $ pprList renderJSON as+    JSObject fs -> braces $ pprList renderField fs+  where+    renderField :: (String, JsonDoc) -> SDoc+    renderField (s, j) = doubleQuotes (text s) <>  colon <+> renderJSON j++    pprList pp xs = hcat (punctuate comma (map pp xs))++escapeJsonString :: String -> String+escapeJsonString = concatMap escapeChar+  where+    escapeChar '\b' = "\\b"+    escapeChar '\f' = "\\f"+    escapeChar '\n' = "\\n"+    escapeChar '\r' = "\\r"+    escapeChar '\t' = "\\t"+    escapeChar '"'  = "\\\""+    escapeChar '\\'  = "\\\\"+    escapeChar c | isControl c || fromEnum c >= 0x7f  = uni_esc c+    escapeChar c = [c]++    uni_esc c = "\\u" ++ (pad 4 (showHex (fromEnum c) ""))++    pad n cs  | len < n   = replicate (n-len) '0' ++ cs+                          | otherwise = cs+                                   where len = length cs++class ToJson a where+  json :: a -> JsonDoc
compiler/GHC/Utils/Lexeme.hs view
@@ -2,7 +2,7 @@ -- -- Functions to evaluate whether or not a string is a valid identifier. -- There is considerable overlap between the logic here and the logic--- in Lexer.x, but sadly there seems to be no way to merge them.+-- in GHC.Parser.Lexer, but sadly there seems to be no way to merge them.  module GHC.Utils.Lexeme (           -- * Lexical characteristics of Haskell names@@ -27,9 +27,9 @@    ) where -import GhcPrelude+import GHC.Prelude -import FastString+import GHC.Data.FastString  import Data.Char import qualified Data.Set as Set@@ -208,7 +208,7 @@                           -- of course, `all` says "True" to an empty list  -- | Is this character acceptable in an identifier (after the first letter)?--- See alexGetByte in Lexer.x+-- See alexGetByte in GHC.Parser.Lexer okIdChar :: Char -> Bool okIdChar c = case generalCategory c of   UppercaseLetter -> True
+ compiler/GHC/Utils/Misc.hs view
@@ -0,0 +1,1465 @@+-- (c) The University of Glasgow 2006++{-# LANGUAGE CPP #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE TupleSections #-}++{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++-- | Highly random utility functions+--+module GHC.Utils.Misc (+        -- * Flags dependent on the compiler build+        ghciSupported, debugIsOn,+        isWindowsHost, isDarwinHost,++        -- * Miscellaneous higher-order functions+        applyWhen, nTimes,++        -- * General list processing+        zipEqual, zipWithEqual, zipWith3Equal, zipWith4Equal,+        zipLazy, stretchZipWith, zipWithAndUnzip, zipAndUnzip,++        zipWithLazy, zipWith3Lazy,++        filterByList, filterByLists, partitionByList,++        unzipWith,++        mapFst, mapSnd, chkAppend,+        mapAndUnzip, mapAndUnzip3, mapAccumL2,+        filterOut, partitionWith,++        dropWhileEndLE, spanEnd, last2, lastMaybe,++        foldl1', foldl2, count, countWhile, all2,++        lengthExceeds, lengthIs, lengthIsNot,+        lengthAtLeast, lengthAtMost, lengthLessThan,+        listLengthCmp, atLength,+        equalLength, compareLength, leLength, ltLength,++        isSingleton, only, singleton,+        notNull, snocView,++        isIn, isn'tIn,++        chunkList,++        changeLast,++        whenNonEmpty,++        -- * Tuples+        fstOf3, sndOf3, thdOf3,+        firstM, first3M, secondM,+        fst3, snd3, third3,+        uncurry3,+        liftFst, liftSnd,++        -- * List operations controlled by another list+        takeList, dropList, splitAtList, split,+        dropTail, capitalise,++        -- * Sorting+        sortWith, minWith, nubSort, ordNub,++        -- * Comparisons+        isEqual, eqListBy, eqMaybeBy,+        thenCmp, cmpList,+        removeSpaces,+        (<&&>), (<||>),++        -- * Edit distance+        fuzzyMatch, fuzzyLookup,++        -- * Transitive closures+        transitiveClosure,++        -- * Strictness+        seqList, strictMap,++        -- * Module names+        looksLikeModuleName,+        looksLikePackageName,++        -- * Argument processing+        getCmd, toCmdArgs, toArgs,++        -- * Integers+        exactLog2,++        -- * Floating point+        readRational,+        readHexRational,++        -- * IO-ish utilities+        doesDirNameExist,+        getModificationUTCTime,+        modificationTimeIfExists,+        withAtomicRename,++        global, consIORef, globalM,+        sharedGlobal, sharedGlobalM,++        -- * Filenames and paths+        Suffix,+        splitLongestPrefix,+        escapeSpaces,+        Direction(..), reslash,+        makeRelativeTo,++        -- * Utils for defining Data instances+        abstractConstr, abstractDataType, mkNoRepType,++        -- * Utils for printing C code+        charToC,++        -- * Hashing+        hashString,++        -- * Call stacks+        HasCallStack,+        HasDebugCallStack,++        -- * Utils for flags+        OverridingBool(..),+        overrideWith,+    ) where++#include "HsVersions.h"++import GHC.Prelude++import GHC.Utils.Exception+import GHC.Utils.Panic.Plain++import Data.Data+import Data.IORef       ( IORef, newIORef, atomicModifyIORef' )+import System.IO.Unsafe ( unsafePerformIO )+import Data.List        hiding (group)+import Data.List.NonEmpty  ( NonEmpty(..) )++import GHC.Exts+import GHC.Stack (HasCallStack)++import Control.Applicative ( liftA2 )+import Control.Monad    ( liftM, guard )+import Control.Monad.IO.Class ( MonadIO, liftIO )+import GHC.Conc.Sync ( sharedCAF )+import System.IO.Error as IO ( isDoesNotExistError )+import System.Directory ( doesDirectoryExist, getModificationTime, renameFile )+import System.FilePath++import Data.Char        ( isUpper, isAlphaNum, isSpace, chr, ord, isDigit, toUpper+                        , isHexDigit, digitToInt )+import Data.Int+import Data.Ratio       ( (%) )+import Data.Ord         ( comparing )+import Data.Bits+import Data.Word+import qualified Data.IntMap as IM+import qualified Data.Set as Set++import Data.Time++#if defined(DEBUG)+import {-# SOURCE #-} GHC.Utils.Outputable ( warnPprTrace, text )+#endif++infixr 9 `thenCmp`++{-+************************************************************************+*                                                                      *+\subsection{Is DEBUG on, are we on Windows, etc?}+*                                                                      *+************************************************************************++These booleans are global constants, set by CPP flags.  They allow us to+recompile a single module (this one) to change whether or not debug output+appears. They sometimes let us avoid even running CPP elsewhere.++It's important that the flags are literal constants (True/False). Then,+with -0, tests of the flags in other modules will simplify to the correct+branch of the conditional, thereby dropping debug code altogether when+the flags are off.+-}++ghciSupported :: Bool+#if defined(HAVE_INTERNAL_INTERPRETER)+ghciSupported = True+#else+ghciSupported = False+#endif++debugIsOn :: Bool+#if defined(DEBUG)+debugIsOn = True+#else+debugIsOn = False+#endif++isWindowsHost :: Bool+#if defined(mingw32_HOST_OS)+isWindowsHost = True+#else+isWindowsHost = False+#endif++isDarwinHost :: Bool+#if defined(darwin_HOST_OS)+isDarwinHost = True+#else+isDarwinHost = False+#endif++{-+************************************************************************+*                                                                      *+\subsection{Miscellaneous higher-order functions}+*                                                                      *+************************************************************************+-}++-- | Apply a function iff some condition is met.+applyWhen :: Bool -> (a -> a) -> a -> a+applyWhen True f x = f x+applyWhen _    _ x = x++-- | A for loop: Compose a function with itself n times.  (nth rather than twice)+nTimes :: Int -> (a -> a) -> (a -> a)+nTimes 0 _ = id+nTimes 1 f = f+nTimes n f = f . nTimes (n-1) f++fstOf3   :: (a,b,c) -> a+sndOf3   :: (a,b,c) -> b+thdOf3   :: (a,b,c) -> c+fstOf3      (a,_,_) =  a+sndOf3      (_,b,_) =  b+thdOf3      (_,_,c) =  c++fst3 :: (a -> d) -> (a, b, c) -> (d, b, c)+fst3 f (a, b, c) = (f a, b, c)++snd3 :: (b -> d) -> (a, b, c) -> (a, d, c)+snd3 f (a, b, c) = (a, f b, c)++third3 :: (c -> d) -> (a, b, c) -> (a, b, d)+third3 f (a, b, c) = (a, b, f c)++uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d+uncurry3 f (a, b, c) = f a b c++liftFst :: (a -> b) -> (a, c) -> (b, c)+liftFst f (a,c) = (f a, c)++liftSnd :: (a -> b) -> (c, a) -> (c, b)+liftSnd f (c,a) = (c, f a)++firstM :: Monad m => (a -> m c) -> (a, b) -> m (c, b)+firstM f (x, y) = liftM (\x' -> (x', y)) (f x)++first3M :: Monad m => (a -> m d) -> (a, b, c) -> m (d, b, c)+first3M f (x, y, z) = liftM (\x' -> (x', y, z)) (f x)++secondM :: Monad m => (b -> m c) -> (a, b) -> m (a, c)+secondM f (x, y) = (x,) <$> f y++{-+************************************************************************+*                                                                      *+\subsection[Utils-lists]{General list processing}+*                                                                      *+************************************************************************+-}++filterOut :: (a->Bool) -> [a] -> [a]+-- ^ Like filter, only it reverses the sense of the test+filterOut _ [] = []+filterOut p (x:xs) | p x       = filterOut p xs+                   | otherwise = x : filterOut p xs++partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])+-- ^ Uses a function to determine which of two output lists an input element should join+partitionWith _ [] = ([],[])+partitionWith f (x:xs) = case f x of+                         Left  b -> (b:bs, cs)+                         Right c -> (bs, c:cs)+    where (bs,cs) = partitionWith f xs++chkAppend :: [a] -> [a] -> [a]+-- Checks for the second argument being empty+-- Used in situations where that situation is common+chkAppend xs ys+  | null ys   = xs+  | otherwise = xs ++ ys++{-+A paranoid @zip@ (and some @zipWith@ friends) that checks the lists+are of equal length.  Alastair Reid thinks this should only happen if+DEBUGging on; hey, why not?+-}++zipEqual        :: String -> [a] -> [b] -> [(a,b)]+zipWithEqual    :: String -> (a->b->c) -> [a]->[b]->[c]+zipWith3Equal   :: String -> (a->b->c->d) -> [a]->[b]->[c]->[d]+zipWith4Equal   :: String -> (a->b->c->d->e) -> [a]->[b]->[c]->[d]->[e]++#if !defined(DEBUG)+zipEqual      _ = zip+zipWithEqual  _ = zipWith+zipWith3Equal _ = zipWith3+zipWith4Equal _ = zipWith4+#else+zipEqual _   []     []     = []+zipEqual msg (a:as) (b:bs) = (a,b) : zipEqual msg as bs+zipEqual msg _      _      = panic ("zipEqual: unequal lists: "++msg)++zipWithEqual msg z (a:as) (b:bs)=  z a b : zipWithEqual msg z as bs+zipWithEqual _   _ [] []        =  []+zipWithEqual msg _ _ _          =  panic ("zipWithEqual: unequal lists: "++msg)++zipWith3Equal msg z (a:as) (b:bs) (c:cs)+                                =  z a b c : zipWith3Equal msg z as bs cs+zipWith3Equal _   _ [] []  []   =  []+zipWith3Equal msg _ _  _   _    =  panic ("zipWith3Equal: unequal lists: "++msg)++zipWith4Equal msg z (a:as) (b:bs) (c:cs) (d:ds)+                                =  z a b c d : zipWith4Equal msg z as bs cs ds+zipWith4Equal _   _ [] [] [] [] =  []+zipWith4Equal msg _ _  _  _  _  =  panic ("zipWith4Equal: unequal lists: "++msg)+#endif++-- | 'zipLazy' is a kind of 'zip' that is lazy in the second list (observe the ~)+zipLazy :: [a] -> [b] -> [(a,b)]+zipLazy []     _       = []+zipLazy (x:xs) ~(y:ys) = (x,y) : zipLazy xs ys++-- | 'zipWithLazy' is like 'zipWith' but is lazy in the second list.+-- The length of the output is always the same as the length of the first+-- list.+zipWithLazy :: (a -> b -> c) -> [a] -> [b] -> [c]+zipWithLazy _ []     _       = []+zipWithLazy f (a:as) ~(b:bs) = f a b : zipWithLazy f as bs++-- | 'zipWith3Lazy' is like 'zipWith3' but is lazy in the second and third lists.+-- The length of the output is always the same as the length of the first+-- list.+zipWith3Lazy :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]+zipWith3Lazy _ []     _       _       = []+zipWith3Lazy f (a:as) ~(b:bs) ~(c:cs) = f a b c : zipWith3Lazy f as bs cs++-- | 'filterByList' takes a list of Bools and a list of some elements and+-- filters out these elements for which the corresponding value in the list of+-- Bools is False. This function does not check whether the lists have equal+-- length.+filterByList :: [Bool] -> [a] -> [a]+filterByList (True:bs)  (x:xs) = x : filterByList bs xs+filterByList (False:bs) (_:xs) =     filterByList bs xs+filterByList _          _      = []++-- | 'filterByLists' takes a list of Bools and two lists as input, and+-- outputs a new list consisting of elements from the last two input lists. For+-- each Bool in the list, if it is 'True', then it takes an element from the+-- former list. If it is 'False', it takes an element from the latter list.+-- The elements taken correspond to the index of the Bool in its list.+-- For example:+--+-- @+-- filterByLists [True, False, True, False] \"abcd\" \"wxyz\" = \"axcz\"+-- @+--+-- This function does not check whether the lists have equal length.+filterByLists :: [Bool] -> [a] -> [a] -> [a]+filterByLists (True:bs)  (x:xs) (_:ys) = x : filterByLists bs xs ys+filterByLists (False:bs) (_:xs) (y:ys) = y : filterByLists bs xs ys+filterByLists _          _      _      = []++-- | 'partitionByList' takes a list of Bools and a list of some elements and+-- partitions the list according to the list of Bools. Elements corresponding+-- to 'True' go to the left; elements corresponding to 'False' go to the right.+-- For example, @partitionByList [True, False, True] [1,2,3] == ([1,3], [2])@+-- This function does not check whether the lists have equal+-- length; when one list runs out, the function stops.+partitionByList :: [Bool] -> [a] -> ([a], [a])+partitionByList = go [] []+  where+    go trues falses (True  : bs) (x : xs) = go (x:trues) falses bs xs+    go trues falses (False : bs) (x : xs) = go trues (x:falses) bs xs+    go trues falses _ _ = (reverse trues, reverse falses)++stretchZipWith :: (a -> Bool) -> b -> (a->b->c) -> [a] -> [b] -> [c]+-- ^ @stretchZipWith p z f xs ys@ stretches @ys@ by inserting @z@ in+-- the places where @p@ returns @True@++stretchZipWith _ _ _ []     _ = []+stretchZipWith p z f (x:xs) ys+  | p x       = f x z : stretchZipWith p z f xs ys+  | otherwise = case ys of+                []     -> []+                (y:ys) -> f x y : stretchZipWith p z f xs ys++mapFst :: (a->c) -> [(a,b)] -> [(c,b)]+mapSnd :: (b->c) -> [(a,b)] -> [(a,c)]++mapFst f xys = [(f x, y) | (x,y) <- xys]+mapSnd f xys = [(x, f y) | (x,y) <- xys]++mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])++mapAndUnzip _ [] = ([], [])+mapAndUnzip f (x:xs)+  = let (r1,  r2)  = f x+        (rs1, rs2) = mapAndUnzip f xs+    in+    (r1:rs1, r2:rs2)++mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])++mapAndUnzip3 _ [] = ([], [], [])+mapAndUnzip3 f (x:xs)+  = let (r1,  r2,  r3)  = f x+        (rs1, rs2, rs3) = mapAndUnzip3 f xs+    in+    (r1:rs1, r2:rs2, r3:rs3)++zipWithAndUnzip :: (a -> b -> (c,d)) -> [a] -> [b] -> ([c],[d])+zipWithAndUnzip f (a:as) (b:bs)+  = let (r1,  r2)  = f a b+        (rs1, rs2) = zipWithAndUnzip f as bs+    in+    (r1:rs1, r2:rs2)+zipWithAndUnzip _ _ _ = ([],[])++-- | This has the effect of making the two lists have equal length by dropping+-- the tail of the longer one.+zipAndUnzip :: [a] -> [b] -> ([a],[b])+zipAndUnzip (a:as) (b:bs)+  = let (rs1, rs2) = zipAndUnzip as bs+    in+    (a:rs1, b:rs2)+zipAndUnzip _ _ = ([],[])++mapAccumL2 :: (s1 -> s2 -> a -> (s1, s2, b)) -> s1 -> s2 -> [a] -> (s1, s2, [b])+mapAccumL2 f s1 s2 xs = (s1', s2', ys)+  where ((s1', s2'), ys) = mapAccumL (\(s1, s2) x -> case f s1 s2 x of+                                                       (s1', s2', y) -> ((s1', s2'), y))+                                     (s1, s2) xs++-- | @atLength atLen atEnd ls n@ unravels list @ls@ to position @n@. Precisely:+--+-- @+--  atLength atLenPred atEndPred ls n+--   | n < 0         = atLenPred ls+--   | length ls < n = atEndPred (n - length ls)+--   | otherwise     = atLenPred (drop n ls)+-- @+atLength :: ([a] -> b)   -- Called when length ls >= n, passed (drop n ls)+                         --    NB: arg passed to this function may be []+         -> b            -- Called when length ls <  n+         -> [a]+         -> Int+         -> b+atLength atLenPred atEnd ls0 n0+  | n0 < 0    = atLenPred ls0+  | otherwise = go n0 ls0+  where+    -- go's first arg n >= 0+    go 0 ls     = atLenPred ls+    go _ []     = atEnd           -- n > 0 here+    go n (_:xs) = go (n-1) xs++-- Some special cases of atLength:++-- | @(lengthExceeds xs n) = (length xs > n)@+lengthExceeds :: [a] -> Int -> Bool+lengthExceeds lst n+  | n < 0+  = True+  | otherwise+  = atLength notNull False lst n++-- | @(lengthAtLeast xs n) = (length xs >= n)@+lengthAtLeast :: [a] -> Int -> Bool+lengthAtLeast = atLength (const True) False++-- | @(lengthIs xs n) = (length xs == n)@+lengthIs :: [a] -> Int -> Bool+lengthIs lst n+  | n < 0+  = False+  | otherwise+  = atLength null False lst n++-- | @(lengthIsNot xs n) = (length xs /= n)@+lengthIsNot :: [a] -> Int -> Bool+lengthIsNot lst n+  | n < 0 = True+  | otherwise = atLength notNull True lst n++-- | @(lengthAtMost xs n) = (length xs <= n)@+lengthAtMost :: [a] -> Int -> Bool+lengthAtMost lst n+  | n < 0+  = False+  | otherwise+  = atLength null True lst n++-- | @(lengthLessThan xs n) == (length xs < n)@+lengthLessThan :: [a] -> Int -> Bool+lengthLessThan = atLength (const False) True++listLengthCmp :: [a] -> Int -> Ordering+listLengthCmp = atLength atLen atEnd+ where+  atEnd = LT    -- Not yet seen 'n' elts, so list length is < n.++  atLen []     = EQ+  atLen _      = GT++equalLength :: [a] -> [b] -> Bool+-- ^ True if length xs == length ys+equalLength []     []     = True+equalLength (_:xs) (_:ys) = equalLength xs ys+equalLength _      _      = False++compareLength :: [a] -> [b] -> Ordering+compareLength []     []     = EQ+compareLength (_:xs) (_:ys) = compareLength xs ys+compareLength []     _      = LT+compareLength _      []     = GT++leLength :: [a] -> [b] -> Bool+-- ^ True if length xs <= length ys+leLength xs ys = case compareLength xs ys of+                   LT -> True+                   EQ -> True+                   GT -> False++ltLength :: [a] -> [b] -> Bool+-- ^ True if length xs < length ys+ltLength xs ys = case compareLength xs ys of+                   LT -> True+                   EQ -> False+                   GT -> False++----------------------------+singleton :: a -> [a]+singleton x = [x]++isSingleton :: [a] -> Bool+isSingleton [_] = True+isSingleton _   = False++notNull :: [a] -> Bool+notNull [] = False+notNull _  = True++only :: [a] -> a+#if defined(DEBUG)+only [a] = a+#else+only (a:_) = a+#endif+only _ = panic "Util: only"++-- Debugging/specialising versions of \tr{elem} and \tr{notElem}++# if !defined(DEBUG)+isIn, isn'tIn :: Eq a => String -> a -> [a] -> Bool+isIn    _msg x ys = x `elem` ys+isn'tIn _msg x ys = x `notElem` ys++# else /* DEBUG */+isIn, isn'tIn :: (HasDebugCallStack, Eq a) => String -> a -> [a] -> Bool+isIn msg x ys+  = elem100 0 x ys+  where+    elem100 :: Eq a => Int -> a -> [a] -> Bool+    elem100 _ _ [] = False+    elem100 i x (y:ys)+      | i > 100 = WARN(True, text ("Over-long elem in " ++ msg)) (x `elem` (y:ys))+      | otherwise = x == y || elem100 (i + 1) x ys++isn'tIn msg x ys+  = notElem100 0 x ys+  where+    notElem100 :: Eq a => Int -> a -> [a] -> Bool+    notElem100 _ _ [] =  True+    notElem100 i x (y:ys)+      | i > 100 = WARN(True, text ("Over-long notElem in " ++ msg)) (x `notElem` (y:ys))+      | otherwise = x /= y && notElem100 (i + 1) x ys+# endif /* DEBUG */+++-- | Split a list into chunks of /n/ elements+chunkList :: Int -> [a] -> [[a]]+chunkList _ [] = []+chunkList n xs = as : chunkList n bs where (as,bs) = splitAt n xs++-- | Replace the last element of a list with another element.+changeLast :: [a] -> a -> [a]+changeLast []     _  = panic "changeLast"+changeLast [_]    x  = [x]+changeLast (x:xs) x' = x : changeLast xs x'++whenNonEmpty :: Applicative m => [a] -> (NonEmpty a -> m ()) -> m ()+whenNonEmpty []     _ = pure ()+whenNonEmpty (x:xs) f = f (x :| xs)++{-+************************************************************************+*                                                                      *+\subsubsection{Sort utils}+*                                                                      *+************************************************************************+-}++minWith :: Ord b => (a -> b) -> [a] -> a+minWith get_key xs = ASSERT( not (null xs) )+                     head (sortWith get_key xs)++nubSort :: Ord a => [a] -> [a]+nubSort = Set.toAscList . Set.fromList++-- | Remove duplicates but keep elements in order.+--   O(n * log n)+ordNub :: Ord a => [a] -> [a]+ordNub xs+  = go Set.empty xs+  where+    go _ [] = []+    go s (x:xs)+      | Set.member x s = go s xs+      | otherwise = x : go (Set.insert x s) xs+++{-+************************************************************************+*                                                                      *+\subsection[Utils-transitive-closure]{Transitive closure}+*                                                                      *+************************************************************************++This algorithm for transitive closure is straightforward, albeit quadratic.+-}++transitiveClosure :: (a -> [a])         -- Successor function+                  -> (a -> a -> Bool)   -- Equality predicate+                  -> [a]+                  -> [a]                -- The transitive closure++transitiveClosure succ eq xs+ = go [] xs+ where+   go done []                      = done+   go done (x:xs) | x `is_in` done = go done xs+                  | otherwise      = go (x:done) (succ x ++ xs)++   _ `is_in` []                 = False+   x `is_in` (y:ys) | eq x y    = True+                    | otherwise = x `is_in` ys++{-+************************************************************************+*                                                                      *+\subsection[Utils-accum]{Accumulating}+*                                                                      *+************************************************************************++A combination of foldl with zip.  It works with equal length lists.+-}++foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc+foldl2 _ z [] [] = z+foldl2 k z (a:as) (b:bs) = foldl2 k (k z a b) as bs+foldl2 _ _ _      _      = panic "Util: foldl2"++all2 :: (a -> b -> Bool) -> [a] -> [b] -> Bool+-- True if the lists are the same length, and+-- all corresponding elements satisfy the predicate+all2 _ []     []     = True+all2 p (x:xs) (y:ys) = p x y && all2 p xs ys+all2 _ _      _      = False++-- Count the number of times a predicate is true++count :: (a -> Bool) -> [a] -> Int+count p = go 0+  where go !n [] = n+        go !n (x:xs) | p x       = go (n+1) xs+                     | otherwise = go n xs++countWhile :: (a -> Bool) -> [a] -> Int+-- Length of an /initial prefix/ of the list satisfying p+countWhile p = go 0+  where go !n (x:xs) | p x = go (n+1) xs+        go !n _            = n++{-+@splitAt@, @take@, and @drop@ but with length of another+list giving the break-off point:+-}++takeList :: [b] -> [a] -> [a]+-- (takeList as bs) trims bs to the be same length+-- as as, unless as is longer in which case it's a no-op+takeList [] _ = []+takeList (_:xs) ls =+   case ls of+     [] -> []+     (y:ys) -> y : takeList xs ys++dropList :: [b] -> [a] -> [a]+dropList [] xs    = xs+dropList _  xs@[] = xs+dropList (_:xs) (_:ys) = dropList xs ys+++splitAtList :: [b] -> [a] -> ([a], [a])+splitAtList [] xs     = ([], xs)+splitAtList _ xs@[]   = (xs, xs)+splitAtList (_:xs) (y:ys) = (y:ys', ys'')+    where+      (ys', ys'') = splitAtList xs ys++-- drop from the end of a list+dropTail :: Int -> [a] -> [a]+-- Specification: dropTail n = reverse . drop n . reverse+-- Better implemention due to Joachim Breitner+-- http://www.joachim-breitner.de/blog/archives/600-On-taking-the-last-n-elements-of-a-list.html+dropTail n xs+  = go (drop n xs) xs+  where+    go (_:ys) (x:xs) = x : go ys xs+    go _      _      = []  -- Stop when ys runs out+                           -- It'll always run out before xs does++-- dropWhile from the end of a list. This is similar to Data.List.dropWhileEnd,+-- but is lazy in the elements and strict in the spine. For reasonably short lists,+-- such as path names and typical lines of text, dropWhileEndLE is generally+-- faster than dropWhileEnd. Its advantage is magnified when the predicate is+-- expensive--using dropWhileEndLE isSpace to strip the space off a line of text+-- is generally much faster than using dropWhileEnd isSpace for that purpose.+-- Specification: dropWhileEndLE p = reverse . dropWhile p . reverse+-- Pay attention to the short-circuit (&&)! The order of its arguments is the only+-- difference between dropWhileEnd and dropWhileEndLE.+dropWhileEndLE :: (a -> Bool) -> [a] -> [a]+dropWhileEndLE p = foldr (\x r -> if null r && p x then [] else x:r) []++-- | @spanEnd p l == reverse (span p (reverse l))@. The first list+-- returns actually comes after the second list (when you look at the+-- input list).+spanEnd :: (a -> Bool) -> [a] -> ([a], [a])+spanEnd p l = go l [] [] l+  where go yes _rev_yes rev_no [] = (yes, reverse rev_no)+        go yes rev_yes  rev_no (x:xs)+          | p x       = go yes (x : rev_yes) rev_no                  xs+          | otherwise = go xs  []            (x : rev_yes ++ rev_no) xs++-- | Get the last two elements in a list. Partial!+{-# INLINE last2 #-}+last2 :: [a] -> (a,a)+last2 = foldl' (\(_,x2) x -> (x2,x)) (partialError,partialError)+  where+    partialError = panic "last2 - list length less than two"++lastMaybe :: [a] -> Maybe a+lastMaybe [] = Nothing+lastMaybe xs = Just $ last xs++-- | Split a list into its last element and the initial part of the list.+-- @snocView xs = Just (init xs, last xs)@ for non-empty lists.+-- @snocView xs = Nothing@ otherwise.+-- Unless both parts of the result are guaranteed to be used+-- prefer separate calls to @last@ + @init@.+-- If you are guaranteed to use both, this will+-- be more efficient.+snocView :: [a] -> Maybe ([a],a)+snocView [] = Nothing+snocView xs+    | (xs,x) <- go xs+    = Just (xs,x)+  where+    go :: [a] -> ([a],a)+    go [x] = ([],x)+    go (x:xs)+        | !(xs',x') <- go xs+        = (x:xs', x')+    go [] = error "impossible"++split :: Char -> String -> [String]+split c s = case rest of+                []     -> [chunk]+                _:rest -> chunk : split c rest+  where (chunk, rest) = break (==c) s++-- | Convert a word to title case by capitalising the first letter+capitalise :: String -> String+capitalise [] = []+capitalise (c:cs) = toUpper c : cs+++{-+************************************************************************+*                                                                      *+\subsection[Utils-comparison]{Comparisons}+*                                                                      *+************************************************************************+-}++isEqual :: Ordering -> Bool+-- Often used in (isEqual (a `compare` b))+isEqual GT = False+isEqual EQ = True+isEqual LT = False++thenCmp :: Ordering -> Ordering -> Ordering+{-# INLINE thenCmp #-}+thenCmp EQ       ordering = ordering+thenCmp ordering _        = ordering++eqListBy :: (a->a->Bool) -> [a] -> [a] -> Bool+eqListBy _  []     []     = True+eqListBy eq (x:xs) (y:ys) = eq x y && eqListBy eq xs ys+eqListBy _  _      _      = False++eqMaybeBy :: (a ->a->Bool) -> Maybe a -> Maybe a -> Bool+eqMaybeBy _  Nothing  Nothing  = True+eqMaybeBy eq (Just x) (Just y) = eq x y+eqMaybeBy _  _        _        = False++cmpList :: (a -> a -> Ordering) -> [a] -> [a] -> Ordering+    -- `cmpList' uses a user-specified comparer++cmpList _   []     [] = EQ+cmpList _   []     _  = LT+cmpList _   _      [] = GT+cmpList cmp (a:as) (b:bs)+  = case cmp a b of { EQ -> cmpList cmp as bs; xxx -> xxx }++removeSpaces :: String -> String+removeSpaces = dropWhileEndLE isSpace . dropWhile isSpace++-- Boolean operators lifted to Applicative+(<&&>) :: Applicative f => f Bool -> f Bool -> f Bool+(<&&>) = liftA2 (&&)+infixr 3 <&&> -- same as (&&)++(<||>) :: Applicative f => f Bool -> f Bool -> f Bool+(<||>) = liftA2 (||)+infixr 2 <||> -- same as (||)++{-+************************************************************************+*                                                                      *+\subsection{Edit distance}+*                                                                      *+************************************************************************+-}++-- | Find the "restricted" Damerau-Levenshtein edit distance between two strings.+-- See: <http://en.wikipedia.org/wiki/Damerau-Levenshtein_distance>.+-- Based on the algorithm presented in "A Bit-Vector Algorithm for Computing+-- Levenshtein and Damerau Edit Distances" in PSC'02 (Heikki Hyyro).+-- See http://www.cs.uta.fi/~helmu/pubs/psc02.pdf and+--     http://www.cs.uta.fi/~helmu/pubs/PSCerr.html for an explanation+restrictedDamerauLevenshteinDistance :: String -> String -> Int+restrictedDamerauLevenshteinDistance str1 str2+  = restrictedDamerauLevenshteinDistanceWithLengths m n str1 str2+  where+    m = length str1+    n = length str2++restrictedDamerauLevenshteinDistanceWithLengths+  :: Int -> Int -> String -> String -> Int+restrictedDamerauLevenshteinDistanceWithLengths m n str1 str2+  | m <= n+  = if n <= 32 -- n must be larger so this check is sufficient+    then restrictedDamerauLevenshteinDistance' (undefined :: Word32) m n str1 str2+    else restrictedDamerauLevenshteinDistance' (undefined :: Integer) m n str1 str2++  | otherwise+  = if m <= 32 -- m must be larger so this check is sufficient+    then restrictedDamerauLevenshteinDistance' (undefined :: Word32) n m str2 str1+    else restrictedDamerauLevenshteinDistance' (undefined :: Integer) n m str2 str1++restrictedDamerauLevenshteinDistance'+  :: (Bits bv, Num bv) => bv -> Int -> Int -> String -> String -> Int+restrictedDamerauLevenshteinDistance' _bv_dummy m n str1 str2+  | [] <- str1 = n+  | otherwise  = extractAnswer $+                 foldl' (restrictedDamerauLevenshteinDistanceWorker+                             (matchVectors str1) top_bit_mask vector_mask)+                        (0, 0, m_ones, 0, m) str2+  where+    m_ones@vector_mask = (2 ^ m) - 1+    top_bit_mask = (1 `shiftL` (m - 1)) `asTypeOf` _bv_dummy+    extractAnswer (_, _, _, _, distance) = distance++restrictedDamerauLevenshteinDistanceWorker+      :: (Bits bv, Num bv) => IM.IntMap bv -> bv -> bv+      -> (bv, bv, bv, bv, Int) -> Char -> (bv, bv, bv, bv, Int)+restrictedDamerauLevenshteinDistanceWorker str1_mvs top_bit_mask vector_mask+                                           (pm, d0, vp, vn, distance) char2+  = seq str1_mvs $ seq top_bit_mask $ seq vector_mask $+    seq pm' $ seq d0' $ seq vp' $ seq vn' $+    seq distance'' $ seq char2 $+    (pm', d0', vp', vn', distance'')+  where+    pm' = IM.findWithDefault 0 (ord char2) str1_mvs++    d0' = ((((sizedComplement vector_mask d0) .&. pm') `shiftL` 1) .&. pm)+      .|. ((((pm' .&. vp) + vp) .&. vector_mask) `xor` vp) .|. pm' .|. vn+          -- No need to mask the shiftL because of the restricted range of pm++    hp' = vn .|. sizedComplement vector_mask (d0' .|. vp)+    hn' = d0' .&. vp++    hp'_shift = ((hp' `shiftL` 1) .|. 1) .&. vector_mask+    hn'_shift = (hn' `shiftL` 1) .&. vector_mask+    vp' = hn'_shift .|. sizedComplement vector_mask (d0' .|. hp'_shift)+    vn' = d0' .&. hp'_shift++    distance' = if hp' .&. top_bit_mask /= 0 then distance + 1 else distance+    distance'' = if hn' .&. top_bit_mask /= 0 then distance' - 1 else distance'++sizedComplement :: Bits bv => bv -> bv -> bv+sizedComplement vector_mask vect = vector_mask `xor` vect++matchVectors :: (Bits bv, Num bv) => String -> IM.IntMap bv+matchVectors = snd . foldl' go (0 :: Int, IM.empty)+  where+    go (ix, im) char = let ix' = ix + 1+                           im' = IM.insertWith (.|.) (ord char) (2 ^ ix) im+                       in seq ix' $ seq im' $ (ix', im')++{-# SPECIALIZE INLINE restrictedDamerauLevenshteinDistance'+                      :: Word32 -> Int -> Int -> String -> String -> Int #-}+{-# SPECIALIZE INLINE restrictedDamerauLevenshteinDistance'+                      :: Integer -> Int -> Int -> String -> String -> Int #-}++{-# SPECIALIZE restrictedDamerauLevenshteinDistanceWorker+               :: IM.IntMap Word32 -> Word32 -> Word32+               -> (Word32, Word32, Word32, Word32, Int)+               -> Char -> (Word32, Word32, Word32, Word32, Int) #-}+{-# SPECIALIZE restrictedDamerauLevenshteinDistanceWorker+               :: IM.IntMap Integer -> Integer -> Integer+               -> (Integer, Integer, Integer, Integer, Int)+               -> Char -> (Integer, Integer, Integer, Integer, Int) #-}++{-# SPECIALIZE INLINE sizedComplement :: Word32 -> Word32 -> Word32 #-}+{-# SPECIALIZE INLINE sizedComplement :: Integer -> Integer -> Integer #-}++{-# SPECIALIZE matchVectors :: String -> IM.IntMap Word32 #-}+{-# SPECIALIZE matchVectors :: String -> IM.IntMap Integer #-}++fuzzyMatch :: String -> [String] -> [String]+fuzzyMatch key vals = fuzzyLookup key [(v,v) | v <- vals]++-- | Search for possible matches to the users input in the given list,+-- returning a small number of ranked results+fuzzyLookup :: String -> [(String,a)] -> [a]+fuzzyLookup user_entered possibilites+  = map fst $ take mAX_RESULTS $ sortBy (comparing snd)+    [ (poss_val, distance) | (poss_str, poss_val) <- possibilites+                       , let distance = restrictedDamerauLevenshteinDistance+                                            poss_str user_entered+                       , distance <= fuzzy_threshold ]+  where+    -- Work out an appropriate match threshold:+    -- We report a candidate if its edit distance is <= the threshold,+    -- The threshold is set to about a quarter of the # of characters the user entered+    --   Length    Threshold+    --     1         0          -- Don't suggest *any* candidates+    --     2         1          -- for single-char identifiers+    --     3         1+    --     4         1+    --     5         1+    --     6         2+    --+    fuzzy_threshold = truncate $ fromIntegral (length user_entered + 2) / (4 :: Rational)+    mAX_RESULTS = 3++{-+************************************************************************+*                                                                      *+\subsection[Utils-pairs]{Pairs}+*                                                                      *+************************************************************************+-}++unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]+unzipWith f pairs = map ( \ (a, b) -> f a b ) pairs++seqList :: [a] -> b -> b+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'++{-+************************************************************************+*                                                                      *+                        Globals and the RTS+*                                                                      *+************************************************************************++When a plugin is loaded, it currently gets linked against a *newly+loaded* copy of the GHC package. This would not be a problem, except+that the new copy has its own mutable state that is not shared with+that state that has already been initialized by the original GHC+package.++(Note that if the GHC executable was dynamically linked this+wouldn't be a problem, because we could share the GHC library it+links to; this is only a problem if DYNAMIC_GHC_PROGRAMS=NO.)++The solution is to make use of @sharedCAF@ through @sharedGlobal@+for globals that are shared between multiple copies of ghc packages.+-}++-- Global variables:++global :: a -> IORef a+global a = unsafePerformIO (newIORef a)++consIORef :: IORef [a] -> a -> IO ()+consIORef var x = do+  atomicModifyIORef' var (\xs -> (x:xs,()))++globalM :: IO a -> IORef a+globalM ma = unsafePerformIO (ma >>= newIORef)++-- Shared global variables:++sharedGlobal :: a -> (Ptr (IORef a) -> IO (Ptr (IORef a))) -> IORef a+sharedGlobal a get_or_set = unsafePerformIO $+  newIORef a >>= flip sharedCAF get_or_set++sharedGlobalM :: IO a -> (Ptr (IORef a) -> IO (Ptr (IORef a))) -> IORef a+sharedGlobalM ma get_or_set = unsafePerformIO $+  ma >>= newIORef >>= flip sharedCAF get_or_set++-- Module names:++looksLikeModuleName :: String -> Bool+looksLikeModuleName [] = False+looksLikeModuleName (c:cs) = isUpper c && go cs+  where go [] = True+        go ('.':cs) = looksLikeModuleName cs+        go (c:cs)   = (isAlphaNum c || c == '_' || c == '\'') && go cs++-- Similar to 'parse' for Distribution.Package.PackageName,+-- but we don't want to depend on Cabal.+looksLikePackageName :: String -> Bool+looksLikePackageName = all (all isAlphaNum <&&> not . (all isDigit)) . split '-'++{-+Akin to @Prelude.words@, but acts like the Bourne shell, treating+quoted strings as Haskell Strings, and also parses Haskell [String]+syntax.+-}++getCmd :: String -> Either String             -- Error+                           (String, String) -- (Cmd, Rest)+getCmd s = case break isSpace $ dropWhile isSpace s of+           ([], _) -> Left ("Couldn't find command in " ++ show s)+           res -> Right res++toCmdArgs :: String -> Either String             -- Error+                              (String, [String]) -- (Cmd, Args)+toCmdArgs s = case getCmd s of+              Left err -> Left err+              Right (cmd, s') -> case toArgs s' of+                                 Left err -> Left err+                                 Right args -> Right (cmd, args)++toArgs :: String -> Either String   -- Error+                           [String] -- Args+toArgs str+    = case dropWhile isSpace str of+      s@('[':_) -> case reads s of+                   [(args, spaces)]+                    | all isSpace spaces ->+                       Right args+                   _ ->+                       Left ("Couldn't read " ++ show str ++ " as [String]")+      s -> toArgs' s+ where+  toArgs' :: String -> Either String [String]+  -- Remove outer quotes:+  -- > toArgs' "\"foo\" \"bar baz\""+  -- Right ["foo", "bar baz"]+  --+  -- Keep inner quotes:+  -- > toArgs' "-DFOO=\"bar baz\""+  -- Right ["-DFOO=\"bar baz\""]+  toArgs' s = case dropWhile isSpace s of+              [] -> Right []+              ('"' : _) -> do+                    -- readAsString removes outer quotes+                    (arg, rest) <- readAsString s+                    (arg:) `fmap` toArgs' rest+              s' -> case break (isSpace <||> (== '"')) s' of+                    (argPart1, s''@('"':_)) -> do+                        (argPart2, rest) <- readAsString s''+                        -- show argPart2 to keep inner quotes+                        ((argPart1 ++ show argPart2):) `fmap` toArgs' rest+                    (arg, s'') -> (arg:) `fmap` toArgs' s''++  readAsString :: String -> Either String (String, String)+  readAsString s = case reads s of+                [(arg, rest)]+                    -- rest must either be [] or start with a space+                    | all isSpace (take 1 rest) ->+                    Right (arg, rest)+                _ ->+                    Left ("Couldn't read " ++ show s ++ " as String")+-----------------------------------------------------------------------------+-- Integers++-- | Determine the $\log_2$ of exact powers of 2+exactLog2 :: Integer -> Maybe Integer+exactLog2 x+   | x <= 0                               = Nothing+   | x > fromIntegral (maxBound :: Int32) = Nothing+   | x' .&. (-x') /= x'                   = Nothing+   | otherwise                            = Just (fromIntegral c)+      where+         x' = fromIntegral x :: Int32+         c = countTrailingZeros x'++{-+-- -----------------------------------------------------------------------------+-- Floats+-}++readRational__ :: ReadS Rational -- NB: doesn't handle leading "-"+readRational__ r = do+     (n,d,s) <- readFix r+     (k,t)   <- readExp s+     return ((n%1)*10^^(k-d), t)+ where+     readFix r = do+        (ds,s)  <- lexDecDigits r+        (ds',t) <- lexDotDigits s+        return (read (ds++ds'), length ds', t)++     readExp (e:s) | e `elem` "eE" = readExp' s+     readExp s                     = return (0,s)++     readExp' ('+':s) = readDec s+     readExp' ('-':s) = do (k,t) <- readDec s+                           return (-k,t)+     readExp' s       = readDec s++     readDec s = do+        (ds,r) <- nonnull isDigit s+        return (foldl1 (\n d -> n * 10 + d) [ ord d - ord '0' | d <- ds ],+                r)++     lexDecDigits = nonnull isDigit++     lexDotDigits ('.':s) = return (span' isDigit s)+     lexDotDigits s       = return ("",s)++     nonnull p s = do (cs@(_:_),t) <- return (span' p s)+                      return (cs,t)++     span' _ xs@[]         =  (xs, xs)+     span' p xs@(x:xs')+               | x == '_'  = span' p xs'   -- skip "_" (#14473)+               | p x       =  let (ys,zs) = span' p xs' in (x:ys,zs)+               | otherwise =  ([],xs)++readRational :: String -> Rational -- NB: *does* handle a leading "-"+readRational top_s+  = case top_s of+      '-' : xs -> - (read_me xs)+      xs       -> read_me xs+  where+    read_me s+      = case (do { (x,"") <- readRational__ s ; return x }) of+          [x] -> x+          []  -> error ("readRational: no parse:"        ++ top_s)+          _   -> error ("readRational: ambiguous parse:" ++ top_s)+++readHexRational :: String -> Rational+readHexRational str =+  case str of+    '-' : xs -> - (readMe xs)+    xs       -> readMe xs+  where+  readMe as =+    case readHexRational__ as of+      Just n -> n+      _      -> error ("readHexRational: no parse:" ++ str)+++readHexRational__ :: String -> Maybe Rational+readHexRational__ ('0' : x : rest)+  | x == 'X' || x == 'x' =+  do let (front,rest2) = span' isHexDigit rest+     guard (not (null front))+     let frontNum = steps 16 0 front+     case rest2 of+       '.' : rest3 ->+          do let (back,rest4) = span' isHexDigit rest3+             guard (not (null back))+             let backNum = steps 16 frontNum back+                 exp1    = -4 * length back+             case rest4 of+               p : ps | isExp p -> fmap (mk backNum . (+ exp1)) (getExp ps)+               _ -> return (mk backNum exp1)+       p : ps | isExp p -> fmap (mk frontNum) (getExp ps)+       _ -> Nothing++  where+  isExp p = p == 'p' || p == 'P'++  getExp ('+' : ds) = dec ds+  getExp ('-' : ds) = fmap negate (dec ds)+  getExp ds         = dec ds++  mk :: Integer -> Int -> Rational+  mk n e = fromInteger n * 2^^e++  dec cs = case span' isDigit cs of+             (ds,"") | not (null ds) -> Just (steps 10 0 ds)+             _ -> Nothing++  steps base n ds = foldl' (step base) n ds+  step  base n d  = base * n + fromIntegral (digitToInt d)++  span' _ xs@[]         =  (xs, xs)+  span' p xs@(x:xs')+            | x == '_'  = span' p xs'   -- skip "_"  (#14473)+            | p x       =  let (ys,zs) = span' p xs' in (x:ys,zs)+            | otherwise =  ([],xs)++readHexRational__ _ = Nothing++-----------------------------------------------------------------------------+-- Verify that the 'dirname' portion of a FilePath exists.+--+doesDirNameExist :: FilePath -> IO Bool+doesDirNameExist fpath = doesDirectoryExist (takeDirectory fpath)++-----------------------------------------------------------------------------+-- Backwards compatibility definition of getModificationTime++getModificationUTCTime :: FilePath -> IO UTCTime+getModificationUTCTime = getModificationTime++-- --------------------------------------------------------------+-- check existence & modification time at the same time++modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime)+modificationTimeIfExists f = do+  (do t <- getModificationUTCTime f; return (Just t))+        `catchIO` \e -> if isDoesNotExistError e+                        then return Nothing+                        else ioError e++-- --------------------------------------------------------------+-- atomic file writing by writing to a temporary file first (see #14533)+--+-- This should be used in all cases where GHC writes files to disk+-- and uses their modification time to skip work later,+-- as otherwise a partially written file (e.g. due to crash or Ctrl+C)+-- also results in a skip.++withAtomicRename :: (MonadIO m) => FilePath -> (FilePath -> m a) -> m a+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.+  -- This can still be fooled when somebody mounts a different file system+  -- at just the right time, but that is not a case we aim to cover here.+  let temp = targetFile <.> "tmp"+  res <- f temp+  liftIO $ renameFile temp targetFile+  return res++-- --------------------------------------------------------------+-- split a string at the last character where 'pred' is True,+-- returning a pair of strings. The first component holds the string+-- up (but not including) the last character for which 'pred' returned+-- True, the second whatever comes after (but also not including the+-- last character).+--+-- If 'pred' returns False for all characters in the string, the original+-- string is returned in the first component (and the second one is just+-- empty).+splitLongestPrefix :: String -> (Char -> Bool) -> (String,String)+splitLongestPrefix str pred+  | null r_pre = (str,           [])+  | otherwise  = (reverse (tail r_pre), reverse r_suf)+                           -- 'tail' drops the char satisfying 'pred'+  where (r_suf, r_pre) = break pred (reverse str)++escapeSpaces :: String -> String+escapeSpaces = foldr (\c s -> if isSpace c then '\\':c:s else c:s) ""++type Suffix = String++--------------------------------------------------------------+-- * Search path+--------------------------------------------------------------++data Direction = Forwards | Backwards++reslash :: Direction -> FilePath -> FilePath+reslash d = f+    where f ('/'  : xs) = slash : f xs+          f ('\\' : xs) = slash : f xs+          f (x    : xs) = x     : f xs+          f ""          = ""+          slash = case d of+                  Forwards -> '/'+                  Backwards -> '\\'++makeRelativeTo :: FilePath -> FilePath -> FilePath+this `makeRelativeTo` that = directory </> thisFilename+    where (thisDirectory, thisFilename) = splitFileName this+          thatDirectory = dropFileName that+          directory = joinPath $ f (splitPath thisDirectory)+                                   (splitPath thatDirectory)++          f (x : xs) (y : ys)+           | x == y = f xs ys+          f xs ys = replicate (length ys) ".." ++ xs++{-+************************************************************************+*                                                                      *+\subsection[Utils-Data]{Utils for defining Data instances}+*                                                                      *+************************************************************************++These functions helps us to define Data instances for abstract types.+-}++abstractConstr :: String -> Constr+abstractConstr n = mkConstr (abstractDataType n) ("{abstract:"++n++"}") [] Prefix++abstractDataType :: String -> DataType+abstractDataType n = mkDataType n [abstractConstr n]++{-+************************************************************************+*                                                                      *+\subsection[Utils-C]{Utils for printing C code}+*                                                                      *+************************************************************************+-}++charToC :: Word8 -> String+charToC w =+  case chr (fromIntegral w) of+        '\"' -> "\\\""+        '\'' -> "\\\'"+        '\\' -> "\\\\"+        c | c >= ' ' && c <= '~' -> [c]+          | otherwise -> ['\\',+                         chr (ord '0' + ord c `div` 64),+                         chr (ord '0' + ord c `div` 8 `mod` 8),+                         chr (ord '0' + ord c         `mod` 8)]++{-+************************************************************************+*                                                                      *+\subsection[Utils-Hashing]{Utils for hashing}+*                                                                      *+************************************************************************+-}++-- | A sample hash function for Strings.  We keep multiplying by the+-- golden ratio and adding.  The implementation is:+--+-- > hashString = foldl' f golden+-- >   where f m c = fromIntegral (ord c) * magic + hashInt32 m+-- >         magic = 0xdeadbeef+--+-- Where hashInt32 works just as hashInt shown above.+--+-- Knuth argues that repeated multiplication by the golden ratio+-- will minimize gaps in the hash space, and thus it's a good choice+-- for combining together multiple keys to form one.+--+-- Here we know that individual characters c are often small, and this+-- produces frequent collisions if we use ord c alone.  A+-- particular problem are the shorter low ASCII and ISO-8859-1+-- character strings.  We pre-multiply by a magic twiddle factor to+-- obtain a good distribution.  In fact, given the following test:+--+-- > testp :: Int32 -> Int+-- > testp k = (n - ) . length . group . sort . map hs . take n $ ls+-- >   where ls = [] : [c : l | l <- ls, c <- ['\0'..'\xff']]+-- >         hs = foldl' f golden+-- >         f m c = fromIntegral (ord c) * k + hashInt32 m+-- >         n = 100000+--+-- We discover that testp magic = 0.+hashString :: String -> Int32+hashString = foldl' f golden+   where f m c = fromIntegral (ord c) * magic + hashInt32 m+         magic = fromIntegral (0xdeadbeef :: Word32)++golden :: Int32+golden = 1013904242 -- = round ((sqrt 5 - 1) * 2^32) :: Int32+-- was -1640531527 = round ((sqrt 5 - 1) * 2^31) :: Int32+-- but that has bad mulHi properties (even adding 2^32 to get its inverse)+-- Whereas the above works well and contains no hash duplications for+-- [-32767..65536]++-- | A sample (and useful) hash function for Int32,+-- implemented by extracting the uppermost 32 bits of the 64-bit+-- result of multiplying by a 33-bit constant.  The constant is from+-- Knuth, derived from the golden ratio:+--+-- > golden = round ((sqrt 5 - 1) * 2^32)+--+-- We get good key uniqueness on small inputs+-- (a problem with previous versions):+--  (length $ group $ sort $ map hashInt32 [-32767..65536]) == 65536 + 32768+--+hashInt32 :: Int32 -> Int32+hashInt32 x = mulHi x golden + x++-- hi 32 bits of a x-bit * 32 bit -> 64-bit multiply+mulHi :: Int32 -> Int32 -> Int32+mulHi a b = fromIntegral (r `shiftR` 32)+   where r :: Int64+         r = fromIntegral a * fromIntegral b++-- | A call stack constraint, but only when 'isDebugOn'.+#if defined(DEBUG)+type HasDebugCallStack = HasCallStack+#else+type HasDebugCallStack = (() :: Constraint)+#endif++data OverridingBool+  = Auto+  | Always+  | Never+  deriving Show++overrideWith :: Bool -> OverridingBool -> Bool+overrideWith b Auto   = b+overrideWith _ Always = True+overrideWith _ Never  = False
+ compiler/GHC/Utils/Monad.hs view
@@ -0,0 +1,215 @@+-- | Utilities related to Monad and Applicative classes+--   Mostly for backwards compatibility.++module GHC.Utils.Monad+        ( Applicative(..)+        , (<$>)++        , MonadFix(..)+        , MonadIO(..)++        , zipWith3M, zipWith3M_, zipWith4M, zipWithAndUnzipM+        , mapAndUnzipM, mapAndUnzip3M, mapAndUnzip4M, mapAndUnzip5M+        , mapAccumLM+        , mapSndM+        , concatMapM+        , mapMaybeM+        , fmapMaybeM, fmapEitherM+        , anyM, allM, orM+        , foldlM, foldlM_, foldrM+        , maybeMapM+        , whenM, unlessM+        , filterOutM+        ) where++-------------------------------------------------------------------------------+-- Imports+-------------------------------------------------------------------------------++import GHC.Prelude++import Control.Applicative+import Control.Monad+import Control.Monad.Fix+import Control.Monad.IO.Class+import Data.Foldable (sequenceA_, foldlM, foldrM)+import Data.List (unzip4, unzip5, zipWith4)++-------------------------------------------------------------------------------+-- Common functions+--  These are used throughout the compiler+-------------------------------------------------------------------------------++{-++Note [Inline @zipWithNM@ functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++The inline principle for 'zipWith3M', 'zipWith4M' and 'zipWith3M_' is the same+as for 'zipWithM' and 'zipWithM_' in "Control.Monad", see+Note [Fusion for zipN/zipWithN] in GHC/List.hs for more details.++The 'zipWithM'/'zipWithM_' functions are inlined so that the `zipWith` and+`sequenceA` functions with which they are defined have an opportunity to fuse.++Furthermore, 'zipWith3M'/'zipWith4M' and 'zipWith3M_' have been explicitly+rewritten in a non-recursive way similarly to 'zipWithM'/'zipWithM_', and for+more than just uniformity: after [D5241](https://phabricator.haskell.org/D5241)+for issue #14037, all @zipN@/@zipWithN@ functions fuse, meaning+'zipWith3M'/'zipWIth4M' and 'zipWith3M_'@ now behave like 'zipWithM' and+'zipWithM_', respectively, with regards to fusion.++As such, since there are not any differences between 2-ary 'zipWithM'/+'zipWithM_' and their n-ary counterparts below aside from the number of+arguments, the `INLINE` pragma should be replicated in the @zipWithNM@+functions below as well.++-}++zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d]+{-# INLINE zipWith3M #-}+-- Inline so that fusion with 'zipWith3' and 'sequenceA' has a chance to fire.+-- See Note [Inline @zipWithNM@ functions] above.+zipWith3M f xs ys zs = sequenceA (zipWith3 f xs ys zs)++zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m ()+{-# INLINE zipWith3M_ #-}+-- Inline so that fusion with 'zipWith4' and 'sequenceA' has a chance to fire.+-- See  Note [Inline @zipWithNM@ functions] above.+zipWith3M_ f xs ys zs = sequenceA_ (zipWith3 f xs ys zs)++zipWith4M :: Monad m => (a -> b -> c -> d -> m e)+          -> [a] -> [b] -> [c] -> [d] -> m [e]+{-# INLINE zipWith4M #-}+-- Inline so that fusion with 'zipWith5' and 'sequenceA' has a chance to fire.+-- See  Note [Inline @zipWithNM@ functions] above.+zipWith4M f xs ys ws zs = sequenceA (zipWith4 f xs ys ws zs)++zipWithAndUnzipM :: Monad m+                 => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])+{-# INLINABLE zipWithAndUnzipM #-}+-- See Note [flatten_args performance] in GHC.Tc.Solver.Flatten for why this+-- pragma is essential.+zipWithAndUnzipM f (x:xs) (y:ys)+  = do { (c, d) <- f x y+       ; (cs, ds) <- zipWithAndUnzipM f xs ys+       ; return (c:cs, d:ds) }+zipWithAndUnzipM _ _ _ = return ([], [])++{-++Note [Inline @mapAndUnzipNM@ functions]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++The inline principle is the same as 'mapAndUnzipM' in "Control.Monad".+The 'mapAndUnzipM' function is inlined so that the `unzip` and `traverse`+functions with which it is defined have an opportunity to fuse, see+Note [Inline @unzipN@ functions] in Data/OldList.hs for more details.++Furthermore, the @mapAndUnzipNM@ functions have been explicitly rewritten in a+non-recursive way similarly to 'mapAndUnzipM', and for more than just+uniformity: after [D5249](https://phabricator.haskell.org/D5249) for Trac+ticket #14037, all @unzipN@ functions fuse, meaning 'mapAndUnzip3M',+'mapAndUnzip4M' and 'mapAndUnzip5M' now behave like 'mapAndUnzipM' with regards+to fusion.++As such, since there are not any differences between 2-ary 'mapAndUnzipM' and+its n-ary counterparts below aside from the number of arguments, the `INLINE`+pragma should be replicated in the @mapAndUnzipNM@ functions below as well.++-}++-- | mapAndUnzipM for triples+mapAndUnzip3M :: Monad m => (a -> m (b,c,d)) -> [a] -> m ([b],[c],[d])+{-# INLINE mapAndUnzip3M #-}+-- Inline so that fusion with 'unzip3' and 'traverse' has a chance to fire.+-- See Note [Inline @mapAndUnzipNM@ functions] above.+mapAndUnzip3M f xs =  unzip3 <$> traverse f xs++mapAndUnzip4M :: Monad m => (a -> m (b,c,d,e)) -> [a] -> m ([b],[c],[d],[e])+{-# INLINE mapAndUnzip4M #-}+-- Inline so that fusion with 'unzip4' and 'traverse' has a chance to fire.+-- See Note [Inline @mapAndUnzipNM@ functions] above.+mapAndUnzip4M f xs =  unzip4 <$> traverse f xs++mapAndUnzip5M :: Monad m => (a -> m (b,c,d,e,f)) -> [a] -> m ([b],[c],[d],[e],[f])+{-# INLINE mapAndUnzip5M #-}+-- Inline so that fusion with 'unzip5' and 'traverse' has a chance to fire.+-- See Note [Inline @mapAndUnzipNM@ functions] above.+mapAndUnzip5M f xs =  unzip5 <$> traverse f xs++-- | Monadic version of mapAccumL+mapAccumLM :: Monad m+            => (acc -> x -> m (acc, y)) -- ^ combining function+            -> acc                      -- ^ initial state+            -> [x]                      -- ^ inputs+            -> m (acc, [y])             -- ^ final state, outputs+mapAccumLM _ s []     = return (s, [])+mapAccumLM f s (x:xs) = do+    (s1, x')  <- f s x+    (s2, xs') <- mapAccumLM f s1 xs+    return    (s2, x' : xs')++-- | Monadic version of mapSnd+mapSndM :: Monad m => (b -> m c) -> [(a,b)] -> m [(a,c)]+mapSndM _ []         = return []+mapSndM f ((a,b):xs) = do { c <- f b; rs <- mapSndM f xs; return ((a,c):rs) }++-- | Monadic version of concatMap+concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]+concatMapM f xs = liftM concat (mapM f xs)++-- | Applicative version of mapMaybe+mapMaybeM :: Applicative m => (a -> m (Maybe b)) -> [a] -> m [b]+mapMaybeM f = foldr g (pure [])+  where g a = liftA2 (maybe id (:)) (f a)++-- | Monadic version of fmap+fmapMaybeM :: (Monad m) => (a -> m b) -> Maybe a -> m (Maybe b)+fmapMaybeM _ Nothing  = return Nothing+fmapMaybeM f (Just x) = f x >>= (return . Just)++-- | Monadic version of fmap+fmapEitherM :: Monad m => (a -> m b) -> (c -> m d) -> Either a c -> m (Either b d)+fmapEitherM fl _ (Left  a) = fl a >>= (return . Left)+fmapEitherM _ fr (Right b) = fr b >>= (return . Right)++-- | Monadic version of 'any', aborts the computation at the first @True@ value+anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool+anyM _ []     = return False+anyM f (x:xs) = do b <- f x+                   if b then return True+                        else anyM f xs++-- | Monad version of 'all', aborts the computation at the first @False@ value+allM :: Monad m => (a -> m Bool) -> [a] -> m Bool+allM _ []     = return True+allM f (b:bs) = (f b) >>= (\bv -> if bv then allM f bs else return False)++-- | Monadic version of or+orM :: Monad m => m Bool -> m Bool -> m Bool+orM m1 m2 = m1 >>= \x -> if x then return True else m2++-- | Monadic version of foldl that discards its result+foldlM_ :: (Monad m, Foldable t) => (a -> b -> m a) -> a -> t b -> m ()+foldlM_ = foldM_++-- | Monadic version of fmap specialised for Maybe+maybeMapM :: Monad m => (a -> m b) -> (Maybe a -> m (Maybe b))+maybeMapM _ Nothing  = return Nothing+maybeMapM m (Just x) = liftM Just $ m x++-- | Monadic version of @when@, taking the condition in the monad+whenM :: Monad m => m Bool -> m () -> m ()+whenM mb thing = do { b <- mb+                    ; when b thing }++-- | Monadic version of @unless@, taking the condition in the monad+unlessM :: Monad m => m Bool -> m () -> m ()+unlessM condM acc = do { cond <- condM+                       ; unless cond acc }++-- | Like 'filterM', only it reverses the sense of the test.+filterOutM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a]+filterOutM p =+  foldr (\ x -> liftA2 (\ flg -> if flg then id else (x:)) (p x)) (pure [])
+ compiler/GHC/Utils/Outputable.hs view
@@ -0,0 +1,1305 @@+{-# LANGUAGE LambdaCase #-}++{-+(c) The University of Glasgow 2006-2012+(c) The GRASP Project, Glasgow University, 1992-1998+-}++-- | This module defines classes and functions for pretty-printing. It also+-- exports a number of helpful debugging and other utilities such as 'trace' and 'panic'.+--+-- The interface to this module is very similar to the standard Hughes-PJ pretty printing+-- module, except that it exports a number of additional functions that are rarely used,+-- and works over the 'SDoc' type.+module GHC.Utils.Outputable (+        -- * Type classes+        Outputable(..), OutputableBndr(..),++        -- * Pretty printing combinators+        SDoc, runSDoc, initSDocContext,+        docToSDoc,+        interppSP, interpp'SP,+        pprQuotedList, pprWithCommas, quotedListWithOr, quotedListWithNor,+        pprWithBars,+        empty, isEmpty, nest,+        char,+        text, ftext, ptext, ztext,+        int, intWithCommas, integer, word, float, double, rational, doublePrec,+        parens, cparen, brackets, braces, quotes, quote,+        doubleQuotes, angleBrackets,+        semi, comma, colon, dcolon, space, equals, dot, vbar,+        arrow, larrow, darrow, arrowt, larrowt, arrowtt, larrowtt,+        lparen, rparen, lbrack, rbrack, lbrace, rbrace, underscore,+        blankLine, forAllLit, bullet,+        (<>), (<+>), hcat, hsep,+        ($$), ($+$), vcat,+        sep, cat,+        fsep, fcat,+        hang, hangNotEmpty, punctuate, ppWhen, ppUnless,+        ppWhenOption, ppUnlessOption,+        speakNth, speakN, speakNOf, plural, isOrAre, doOrDoes, itsOrTheir,+        unicodeSyntax,++        coloured, keyword,++        -- * Converting 'SDoc' into strings and outputting it+        printSDoc, printSDocLn, printForUser, printForUserPartWay,+        printForC, bufLeftRenderSDoc,+        pprCode, mkCodeStyle,+        showSDoc, showSDocUnsafe, showSDocOneLine,+        showSDocForUser, showSDocDebug, showSDocDump, showSDocDumpOneLine,+        showSDocUnqual, showPpr,+        renderWithStyle,++        pprInfixVar, pprPrefixVar,+        pprHsChar, pprHsString, pprHsBytes,++        primFloatSuffix, primCharSuffix, primWordSuffix, primDoubleSuffix,+        primInt64Suffix, primWord64Suffix, primIntSuffix,++        pprPrimChar, pprPrimInt, pprPrimWord, pprPrimInt64, pprPrimWord64,++        pprFastFilePath, pprFilePathString,++        -- * Controlling the style in which output is printed+        BindingSite(..),++        PprStyle, CodeStyle(..), PrintUnqualified(..),+        QueryQualifyName, QueryQualifyModule, QueryQualifyPackage,+        reallyAlwaysQualify, reallyAlwaysQualifyNames,+        alwaysQualify, alwaysQualifyNames, alwaysQualifyModules,+        neverQualify, neverQualifyNames, neverQualifyModules,+        alwaysQualifyPackages, neverQualifyPackages,+        QualifyName(..), queryQual,+        sdocWithDynFlags, 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,++        -- * Error handling and debugging utilities+        pprPanic, pprSorry, assertPprPanic, pprPgmError,+        pprTrace, pprTraceDebug, pprTraceWith, pprTraceIt, warnPprTrace,+        pprSTrace, pprTraceException, pprTraceM, pprTraceWithFlags,+        trace, pgmError, panic, sorry, assertPanic,+        pprDebugAndThen, callStackDoc,+    ) where++import GHC.Prelude++import {-# SOURCE #-}   GHC.Driver.Session+                           ( DynFlags, hasPprDebug, hasNoDebugOutput+                           , pprUserLength+                           , unsafeGlobalDynFlags, initSDocContext+                           )+import {-# SOURCE #-}   GHC.Unit.Types ( Unit, Module, moduleName )+import {-# SOURCE #-}   GHC.Unit.Module.Name( ModuleName )+import {-# SOURCE #-}   GHC.Types.Name.Occurrence( OccName )++import GHC.Utils.BufHandle (BufHandle)+import GHC.Data.FastString+import qualified GHC.Utils.Ppr as Pretty+import GHC.Utils.Misc+import qualified GHC.Utils.Ppr.Colour as Col+import GHC.Utils.Ppr       ( Doc, Mode(..) )+import GHC.Utils.Panic+import GHC.Serialized+import GHC.LanguageExtensions (Extension)++import Data.ByteString (ByteString)+import qualified Data.ByteString as BS+import Data.Char+import qualified Data.Map as M+import Data.Int+import qualified Data.IntMap as IM+import Data.Set (Set)+import qualified Data.Set as Set+import Data.String+import Data.Word+import System.IO        ( Handle )+import System.FilePath+import Text.Printf+import Numeric (showFFloat)+import Data.Graph (SCC(..))+import Data.List (intersperse)+import Data.List.NonEmpty (NonEmpty (..))+import qualified Data.List.NonEmpty as NEL++import GHC.Fingerprint+import GHC.Show         ( showMultiLineString )+import GHC.Stack        ( callStack, prettyCallStack )+import Control.Monad.IO.Class+import GHC.Utils.Exception++{-+************************************************************************+*                                                                      *+\subsection{The @PprStyle@ data type}+*                                                                      *+************************************************************************+-}++data PprStyle+  = PprUser PrintUnqualified Depth Coloured+                -- Pretty-print in a way that will make sense to the+                -- ordinary user; must be very close to Haskell+                -- syntax, etc.+                -- Assumes printing tidied code: non-system names are+                -- printed without uniques.++  | PprDump PrintUnqualified+                -- For -ddump-foo; less verbose than PprDebug, but more than PprUser+                -- Does not assume tidied code: non-external names+                -- are printed with uniques.++  | PprDebug    -- Full debugging output++  | PprCode CodeStyle+                -- Print code; either C or assembler++data CodeStyle = CStyle         -- The format of labels differs for C and assembler+               | AsmStyle++data Depth = AllTheWay+           | PartWay Int        -- 0 => stop++data Coloured+  = Uncoloured+  | Coloured++-- -----------------------------------------------------------------------------+-- Printing original names++-- | When printing code that contains original names, we need to map the+-- original names back to something the user understands.  This is the+-- purpose of the triple of functions that gets passed around+-- when rendering 'SDoc'.+data PrintUnqualified = QueryQualify {+    queryQualifyName    :: QueryQualifyName,+    queryQualifyModule  :: QueryQualifyModule,+    queryQualifyPackage :: QueryQualifyPackage+}++-- | Given a `Name`'s `Module` and `OccName`, decide whether and how to qualify+-- it.+type QueryQualifyName = Module -> OccName -> QualifyName++-- | For a given module, we need to know whether to print it with+-- a package name to disambiguate it.+type QueryQualifyModule = Module -> Bool++-- | For a given package, we need to know whether to print it with+-- the component id to disambiguate it.+type QueryQualifyPackage = Unit -> Bool++-- 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++  | NameQual ModuleName  -- It's in scope qualified as "X.T"++  | NameNotInScope1      -- It's not in scope at all, but M.T is not bound+                         -- in the current scope, so we can refer to it as "M.T"++  | NameNotInScope2      -- It's not in scope at all, and M.T is already bound in+                         -- the current scope, so we must refer to it as "P:M.T"++instance Outputable QualifyName where+  ppr NameUnqual      = text "NameUnqual"+  ppr (NameQual _mod) = text "NameQual"  -- can't print the mod without module loops :(+  ppr NameNotInScope1 = text "NameNotInScope1"+  ppr NameNotInScope2 = text "NameNotInScope2"++reallyAlwaysQualifyNames :: QueryQualifyName+reallyAlwaysQualifyNames _ _ = NameNotInScope2++-- | NB: This won't ever show package IDs+alwaysQualifyNames :: QueryQualifyName+alwaysQualifyNames m _ = NameQual (moduleName m)++neverQualifyNames :: QueryQualifyName+neverQualifyNames _ _ = NameUnqual++alwaysQualifyModules :: QueryQualifyModule+alwaysQualifyModules _ = True++neverQualifyModules :: QueryQualifyModule+neverQualifyModules _ = False++alwaysQualifyPackages :: QueryQualifyPackage+alwaysQualifyPackages _ = True++neverQualifyPackages :: QueryQualifyPackage+neverQualifyPackages _ = False++reallyAlwaysQualify, alwaysQualify, neverQualify :: PrintUnqualified+reallyAlwaysQualify+              = QueryQualify reallyAlwaysQualifyNames+                             alwaysQualifyModules+                             alwaysQualifyPackages+alwaysQualify = QueryQualify alwaysQualifyNames+                             alwaysQualifyModules+                             alwaysQualifyPackages+neverQualify  = QueryQualify neverQualifyNames+                             neverQualifyModules+                             neverQualifyPackages++defaultUserStyle :: DynFlags -> PprStyle+defaultUserStyle dflags = mkUserStyle dflags neverQualify AllTheWay++defaultDumpStyle :: DynFlags -> PprStyle+ -- Print without qualifiers to reduce verbosity, unless -dppr-debug+defaultDumpStyle dflags+   | hasPprDebug dflags = PprDebug+   | otherwise          = PprDump neverQualify++mkDumpStyle :: DynFlags -> PrintUnqualified -> PprStyle+mkDumpStyle dflags print_unqual+   | hasPprDebug dflags = PprDebug+   | otherwise          = PprDump print_unqual++defaultErrStyle :: DynFlags -> PprStyle+-- Default style for error messages, when we don't know PrintUnqualified+-- It's a bit of a hack because it doesn't take into account what's in scope+-- Only used for desugarer warnings, and typechecker errors in interface sigs+-- NB that -dppr-debug will still get into PprDebug style+defaultErrStyle dflags = mkErrStyle dflags neverQualify++-- | Style for printing error messages+mkErrStyle :: DynFlags -> PrintUnqualified -> PprStyle+mkErrStyle dflags qual =+   mkUserStyle dflags qual (PartWay (pprUserLength dflags))++cmdlineParserStyle :: DynFlags -> PprStyle+cmdlineParserStyle dflags = mkUserStyle dflags alwaysQualify AllTheWay++mkUserStyle :: DynFlags -> PrintUnqualified -> Depth -> PprStyle+mkUserStyle dflags unqual depth+   | 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+    PprUser q d _ -> PprUser q d c+    _             -> style+  where+    c | col       = Coloured+      | otherwise = Uncoloured++instance Outputable PprStyle where+  ppr (PprUser {})  = text "user-style"+  ppr (PprCode {})  = text "code-style"+  ppr (PprDump {})  = text "dump-style"+  ppr (PprDebug {}) = text "debug-style"++{-+Orthogonal to the above printing styles are (possibly) some+command-line flags that affect printing (often carried with the+style).  The most likely ones are variations on how much type info is+shown.++The following test decides whether or not we are actually generating+code (either C or assembly), or generating interface files.++************************************************************************+*                                                                      *+\subsection{The @SDoc@ data type}+*                                                                      *+************************************************************************+-}++-- | Represents a pretty-printable document.+--+-- To display an 'SDoc', use 'printSDoc', 'printSDocLn', 'bufLeftRenderSDoc',+-- or 'renderWithStyle'.  Avoid calling 'runSDoc' directly as it breaks the+-- abstraction layer.+newtype SDoc = SDoc { runSDoc :: SDocContext -> Doc }++data SDocContext = SDC+  { 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+  , 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+  fromString = text++-- The lazy programmer's friend.+instance Outputable SDoc where+  ppr = id+++withPprStyle :: PprStyle -> SDoc -> SDoc+withPprStyle sty d = SDoc $ \ctxt -> runSDoc d ctxt{sdocStyle=sty}++pprDeeper :: SDoc -> SDoc+pprDeeper d = SDoc $ \ctx -> case ctx of+  SDC{sdocStyle=PprUser _ (PartWay 0) _} -> Pretty.text "..."+  SDC{sdocStyle=PprUser q (PartWay n) c} ->+    runSDoc d ctx{sdocStyle = PprUser q (PartWay (n-1)) c}+  _ -> runSDoc d ctx++-- | Truncate a list that is longer than the current depth.+pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc+pprDeeperList f ds+  | null ds   = f []+  | otherwise = SDoc work+ where+  work ctx@SDC{sdocStyle=PprUser q (PartWay n) c}+   | n==0      = Pretty.text "..."+   | otherwise =+      runSDoc (f (go 0 ds)) ctx{sdocStyle = PprUser q (PartWay (n-1)) c}+   where+     go _ [] = []+     go i (d:ds) | i >= n    = [text "...."]+                 | otherwise = d : go (i+1) ds+  work other_ctx = runSDoc (f ds) other_ctx++pprSetDepth :: Depth -> SDoc -> SDoc+pprSetDepth depth doc = SDoc $ \ctx ->+    case ctx of+        SDC{sdocStyle=PprUser q _ c} ->+            runSDoc doc ctx{sdocStyle = PprUser q depth c}+        _ ->+            runSDoc doc ctx++getPprStyle :: (PprStyle -> SDoc) -> SDoc+getPprStyle df = SDoc $ \ctx -> runSDoc (df (sdocStyle ctx)) ctx++sdocWithDynFlags :: (DynFlags -> SDoc) -> SDoc+sdocWithDynFlags f = SDoc $ \ctx -> runSDoc (f (sdocDynFlags ctx)) 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+qualName _other          mod _   = NameQual (moduleName mod)++qualModule :: PprStyle -> QueryQualifyModule+qualModule (PprUser q _ _)  m = queryQualifyModule q m+qualModule (PprDump q)      m = queryQualifyModule q m+qualModule _other          _m = True++qualPackage :: PprStyle -> QueryQualifyPackage+qualPackage (PprUser q _ _)  m = queryQualifyPackage q m+qualPackage (PprDump q)      m = queryQualifyPackage q m+qualPackage _other          _m = True++queryQual :: PprStyle -> PrintUnqualified+queryQual s = QueryQualify (qualName s)+                           (qualModule s)+                           (qualPackage s)++codeStyle :: PprStyle -> Bool+codeStyle (PprCode _)     = True+codeStyle _               = False++asmStyle :: PprStyle -> Bool+asmStyle (PprCode AsmStyle)  = True+asmStyle _other              = False++dumpStyle :: PprStyle -> Bool+dumpStyle (PprDump {}) = True+dumpStyle _other       = False++debugStyle :: PprStyle -> Bool+debugStyle PprDebug = True+debugStyle _other   = False++userStyle ::  PprStyle -> Bool+userStyle (PprUser {}) = True+userStyle _other       = False++getPprDebug :: (Bool -> SDoc) -> SDoc+getPprDebug d = getPprStyle $ \ sty -> d (debugStyle sty)++ifPprDebug :: SDoc -> SDoc -> SDoc+-- ^ Says what to do with and without -dppr-debug+ifPprDebug yes no = getPprDebug $ \ dbg -> if dbg then yes else no++whenPprDebug :: SDoc -> SDoc        -- Empty for non-debug style+-- ^ Says what to do with -dppr-debug; without, return empty+whenPprDebug d = ifPprDebug d empty++-- | The analog of 'Pretty.printDoc_' for 'SDoc', which tries to make sure the+--   terminal doesn't get screwed up by the ANSI color codes if an exception+--   is thrown during pretty-printing.+printSDoc :: SDocContext -> Mode -> Handle -> SDoc -> IO ()+printSDoc ctx mode handle doc =+  Pretty.printDoc_ mode cols handle (runSDoc doc ctx)+    `finally`+      Pretty.printDoc_ mode cols handle+        (runSDoc (coloured Col.colReset empty) ctx)+  where+    cols = sdocLineLength ctx++-- | Like 'printSDoc' but appends an extra newline.+printSDocLn :: SDocContext -> Mode -> Handle -> SDoc -> IO ()+printSDocLn ctx mode handle doc =+  printSDoc ctx mode handle (doc $$ text "")++printForUser :: DynFlags -> Handle -> PrintUnqualified -> SDoc -> IO ()+printForUser dflags handle unqual doc+  = printSDocLn ctx PageMode handle doc+    where ctx = initSDocContext dflags (mkUserStyle dflags unqual AllTheWay)++printForUserPartWay :: DynFlags -> Handle -> Int -> PrintUnqualified -> SDoc+                    -> IO ()+printForUserPartWay dflags handle d unqual doc+  = printSDocLn ctx PageMode handle doc+    where ctx = initSDocContext dflags (mkUserStyle dflags unqual (PartWay d))++-- | Like 'printSDocLn' but specialized with 'LeftMode' and+-- @'PprCode' 'CStyle'@.  This is typically used to output C-- code.+printForC :: DynFlags -> Handle -> SDoc -> IO ()+printForC dflags handle doc =+  printSDocLn ctx LeftMode handle doc+  where ctx = initSDocContext dflags (PprCode CStyle)++-- | An efficient variant of 'printSDoc' specialized for 'LeftMode' that+-- outputs to a 'BufHandle'.+bufLeftRenderSDoc :: SDocContext -> BufHandle -> SDoc -> IO ()+bufLeftRenderSDoc ctx bufHandle doc =+  Pretty.bufLeftRender bufHandle (runSDoc doc ctx)++pprCode :: CodeStyle -> SDoc -> SDoc+pprCode cs d = withPprStyle (PprCode cs) d++mkCodeStyle :: CodeStyle -> PprStyle+mkCodeStyle = PprCode++-- Can't make SDoc an instance of Show because SDoc is just a function type+-- However, Doc *is* an instance of Show+-- showSDoc just blasts it out as a string+showSDoc :: DynFlags -> SDoc -> String+showSDoc dflags sdoc = renderWithStyle (initSDocContext dflags (defaultUserStyle dflags)) sdoc++-- showSDocUnsafe is unsafe, because `unsafeGlobalDynFlags` might not be+-- initialised yet.+showSDocUnsafe :: SDoc -> String+showSDocUnsafe sdoc = showSDoc unsafeGlobalDynFlags sdoc++showPpr :: Outputable a => DynFlags -> a -> String+showPpr dflags thing = showSDoc dflags (ppr thing)++showSDocUnqual :: DynFlags -> SDoc -> String+-- Only used by Haddock+showSDocUnqual dflags sdoc = showSDoc dflags sdoc++showSDocForUser :: DynFlags -> PrintUnqualified -> SDoc -> String+-- Allows caller to specify the PrintUnqualified to use+showSDocForUser dflags unqual doc+ = renderWithStyle (initSDocContext dflags (mkUserStyle dflags unqual AllTheWay)) doc++showSDocDump :: DynFlags -> SDoc -> String+showSDocDump dflags d = renderWithStyle (initSDocContext dflags (defaultDumpStyle dflags)) d++showSDocDebug :: DynFlags -> SDoc -> String+showSDocDebug dflags d = renderWithStyle (initSDocContext dflags PprDebug) d++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"+-- and "foo{uniq strictness}" so we don't want fancy layout anyway.+showSDocOneLine :: SDocContext -> SDoc -> String+showSDocOneLine ctx d+ = let s = Pretty.style{ Pretty.mode = OneLineMode,+                         Pretty.lineLength = sdocLineLength ctx } in+   Pretty.renderStyle s $+      runSDoc d ctx++showSDocDumpOneLine :: DynFlags -> SDoc -> String+showSDocDumpOneLine dflags d+ = let s = Pretty.style{ Pretty.mode = OneLineMode,+                         Pretty.lineLength = irrelevantNCols } in+   Pretty.renderStyle s $+      runSDoc d (initSDocContext dflags (defaultDumpStyle dflags))++irrelevantNCols :: Int+-- Used for OneLineMode and LeftMode when number of cols isn't used+irrelevantNCols = 1++isEmpty :: SDocContext -> SDoc -> Bool+isEmpty ctx sdoc = Pretty.isEmpty $ runSDoc sdoc (ctx {sdocStyle = PprDebug})++docToSDoc :: Doc -> SDoc+docToSDoc d = SDoc (\_ -> d)++empty    :: SDoc+char     :: Char       -> SDoc+text     :: String     -> SDoc+ftext    :: FastString -> SDoc+ptext    :: PtrString  -> SDoc+ztext    :: FastZString -> SDoc+int      :: Int        -> SDoc+integer  :: Integer    -> SDoc+word     :: Integer    -> SDoc+float    :: Float      -> SDoc+double   :: Double     -> SDoc+rational :: Rational   -> SDoc++empty       = docToSDoc $ Pretty.empty+char c      = docToSDoc $ Pretty.char c++text s      = docToSDoc $ Pretty.text s+{-# INLINE text #-}   -- Inline so that the RULE Pretty.text will fire++ftext s     = docToSDoc $ Pretty.ftext s+ptext s     = docToSDoc $ Pretty.ptext s+ztext s     = docToSDoc $ Pretty.ztext s+int n       = docToSDoc $ Pretty.int n+integer n   = docToSDoc $ Pretty.integer n+float n     = docToSDoc $ Pretty.float n+double n    = docToSDoc $ Pretty.double n+rational n  = docToSDoc $ Pretty.rational n+              -- See Note [Print Hexadecimal Literals] in GHC.Utils.Ppr+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.+doublePrec :: Int -> Double -> SDoc+doublePrec p n = text (showFFloat (Just p) n "")++parens, braces, brackets, quotes, quote,+        doubleQuotes, angleBrackets :: SDoc -> SDoc++parens d        = SDoc $ Pretty.parens . runSDoc d+braces d        = SDoc $ Pretty.braces . runSDoc d+brackets d      = SDoc $ Pretty.brackets . runSDoc d+quote d         = SDoc $ Pretty.quote . runSDoc d+doubleQuotes d  = SDoc $ Pretty.doubleQuotes . runSDoc d+angleBrackets d = char '<' <> d <> char '>'++cparen :: Bool -> SDoc -> SDoc+cparen b d = SDoc $ Pretty.maybeParens b . runSDoc d++-- '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 = 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+lparen, rparen, lbrack, rbrack, lbrace, rbrace, blankLine :: SDoc++blankLine  = docToSDoc $ Pretty.text ""+dcolon     = unicodeSyntax (char '∷') (docToSDoc $ Pretty.text "::")+arrow      = unicodeSyntax (char '→') (docToSDoc $ Pretty.text "->")+larrow     = unicodeSyntax (char '←') (docToSDoc $ Pretty.text "<-")+darrow     = unicodeSyntax (char '⇒') (docToSDoc $ Pretty.text "=>")+arrowt     = unicodeSyntax (char '⤚') (docToSDoc $ Pretty.text ">-")+larrowt    = unicodeSyntax (char '⤙') (docToSDoc $ Pretty.text "-<")+arrowtt    = unicodeSyntax (char '⤜') (docToSDoc $ Pretty.text ">>-")+larrowtt   = unicodeSyntax (char '⤛') (docToSDoc $ Pretty.text "-<<")+semi       = docToSDoc $ Pretty.semi+comma      = docToSDoc $ Pretty.comma+colon      = docToSDoc $ Pretty.colon+equals     = docToSDoc $ Pretty.equals+space      = docToSDoc $ Pretty.space+underscore = char '_'+dot        = char '.'+vbar       = char '|'+lparen     = docToSDoc $ Pretty.lparen+rparen     = docToSDoc $ Pretty.rparen+lbrack     = docToSDoc $ Pretty.lbrack+rbrack     = docToSDoc $ Pretty.rbrack+lbrace     = docToSDoc $ Pretty.lbrace+rbrace     = docToSDoc $ Pretty.rbrace++forAllLit :: SDoc+forAllLit = unicodeSyntax (char '∀') (text "forall")++bullet :: SDoc+bullet = unicode (char '•') (char '*')++unicodeSyntax :: SDoc -> SDoc -> SDoc+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 = sdocOption sdocCanUseUnicode $ \case+   True  -> unicode+   False -> plain++nest :: Int -> SDoc -> SDoc+-- ^ Indent 'SDoc' some specified amount+(<>) :: SDoc -> SDoc -> SDoc+-- ^ Join two 'SDoc' together horizontally without a gap+(<+>) :: SDoc -> SDoc -> SDoc+-- ^ Join two 'SDoc' together horizontally with a gap between them+($$) :: SDoc -> SDoc -> SDoc+-- ^ Join two 'SDoc' together vertically; if there is+-- no vertical overlap it "dovetails" the two onto one line+($+$) :: SDoc -> SDoc -> SDoc+-- ^ Join two 'SDoc' together vertically++nest n d    = SDoc $ Pretty.nest n . runSDoc d+(<>) d1 d2  = SDoc $ \sty -> (Pretty.<>)  (runSDoc d1 sty) (runSDoc d2 sty)+(<+>) d1 d2 = SDoc $ \sty -> (Pretty.<+>) (runSDoc d1 sty) (runSDoc d2 sty)+($$) d1 d2  = SDoc $ \sty -> (Pretty.$$)  (runSDoc d1 sty) (runSDoc d2 sty)+($+$) d1 d2 = SDoc $ \sty -> (Pretty.$+$) (runSDoc d1 sty) (runSDoc d2 sty)++hcat :: [SDoc] -> SDoc+-- ^ Concatenate 'SDoc' horizontally+hsep :: [SDoc] -> SDoc+-- ^ Concatenate 'SDoc' horizontally with a space between each one+vcat :: [SDoc] -> SDoc+-- ^ Concatenate 'SDoc' vertically with dovetailing+sep :: [SDoc] -> SDoc+-- ^ Separate: is either like 'hsep' or like 'vcat', depending on what fits+cat :: [SDoc] -> SDoc+-- ^ Catenate: is either like 'hcat' or like 'vcat', depending on what fits+fsep :: [SDoc] -> SDoc+-- ^ A paragraph-fill combinator. It's much like sep, only it+-- keeps fitting things on one line until it can't fit any more.+fcat :: [SDoc] -> SDoc+-- ^ This behaves like 'fsep', but it uses '<>' for horizontal conposition rather than '<+>'+++hcat ds = SDoc $ \sty -> Pretty.hcat [runSDoc d sty | d <- ds]+hsep ds = SDoc $ \sty -> Pretty.hsep [runSDoc d sty | d <- ds]+vcat ds = SDoc $ \sty -> Pretty.vcat [runSDoc d sty | d <- ds]+sep ds  = SDoc $ \sty -> Pretty.sep  [runSDoc d sty | d <- ds]+cat ds  = SDoc $ \sty -> Pretty.cat  [runSDoc d sty | d <- ds]+fsep ds = SDoc $ \sty -> Pretty.fsep [runSDoc d sty | d <- ds]+fcat ds = SDoc $ \sty -> Pretty.fcat [runSDoc d sty | d <- ds]++hang :: SDoc  -- ^ The header+      -> Int  -- ^ Amount to indent the hung body+      -> SDoc -- ^ The hung body, indented and placed below the header+      -> SDoc+hang d1 n d2   = SDoc $ \sty -> Pretty.hang (runSDoc d1 sty) n (runSDoc d2 sty)++-- | This behaves like 'hang', but does not indent the second document+-- when the header is empty.+hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc+hangNotEmpty d1 n d2 =+    SDoc $ \sty -> Pretty.hangNotEmpty (runSDoc d1 sty) n (runSDoc d2 sty)++punctuate :: SDoc   -- ^ The punctuation+          -> [SDoc] -- ^ The list that will have punctuation added between every adjacent pair of elements+          -> [SDoc] -- ^ Punctuated list+punctuate _ []     = []+punctuate p (d:ds) = go d ds+                   where+                     go d [] = [d]+                     go d (e:es) = (d <> p) : go e es++ppWhen, ppUnless :: Bool -> SDoc -> SDoc+ppWhen True  doc = doc+ppWhen False _   = empty++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 = 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++{-+************************************************************************+*                                                                      *+\subsection[Outputable-class]{The @Outputable@ class}+*                                                                      *+************************************************************************+-}++-- | Class designating that some type has an 'SDoc' representation+class Outputable a where+        ppr :: a -> SDoc+        pprPrec :: Rational -> a -> SDoc+                -- 0 binds least tightly+                -- We use Rational because there is always a+                -- Rational between any other two Rationals++        ppr = pprPrec 0+        pprPrec _ = ppr++instance Outputable Char where+    ppr c = text [c]++instance Outputable Bool where+    ppr True  = text "True"+    ppr False = text "False"++instance Outputable Ordering where+    ppr LT = text "LT"+    ppr EQ = text "EQ"+    ppr GT = text "GT"++instance Outputable Int32 where+   ppr n = integer $ fromIntegral n++instance Outputable Int64 where+   ppr n = integer $ fromIntegral n++instance Outputable Int where+    ppr n = int n++instance Outputable Integer where+    ppr n = integer n++instance Outputable Word16 where+    ppr n = integer $ fromIntegral n++instance Outputable Word32 where+    ppr n = integer $ fromIntegral n++instance Outputable Word where+    ppr n = integer $ fromIntegral n++instance Outputable Float where+    ppr f = float f++instance Outputable Double where+    ppr f = double f++instance Outputable () where+    ppr _ = text "()"++instance (Outputable a) => Outputable [a] where+    ppr xs = brackets (fsep (punctuate comma (map ppr xs)))++instance (Outputable a) => Outputable (NonEmpty a) where+    ppr = ppr . NEL.toList++instance (Outputable a) => Outputable (Set a) where+    ppr s = braces (fsep (punctuate comma (map ppr (Set.toList s))))++instance (Outputable a, Outputable b) => Outputable (a, b) where+    ppr (x,y) = parens (sep [ppr x <> comma, ppr y])++instance Outputable a => Outputable (Maybe a) where+    ppr Nothing  = text "Nothing"+    ppr (Just x) = text "Just" <+> ppr x++instance (Outputable a, Outputable b) => Outputable (Either a b) where+    ppr (Left x)  = text "Left"  <+> ppr x+    ppr (Right y) = text "Right" <+> ppr y++-- ToDo: may not be used+instance (Outputable a, Outputable b, Outputable c) => Outputable (a, b, c) where+    ppr (x,y,z) =+      parens (sep [ppr x <> comma,+                   ppr y <> comma,+                   ppr z ])++instance (Outputable a, Outputable b, Outputable c, Outputable d) =>+         Outputable (a, b, c, d) where+    ppr (a,b,c,d) =+      parens (sep [ppr a <> comma,+                   ppr b <> comma,+                   ppr c <> comma,+                   ppr d])++instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) =>+         Outputable (a, b, c, d, e) where+    ppr (a,b,c,d,e) =+      parens (sep [ppr a <> comma,+                   ppr b <> comma,+                   ppr c <> comma,+                   ppr d <> comma,+                   ppr e])++instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) =>+         Outputable (a, b, c, d, e, f) where+    ppr (a,b,c,d,e,f) =+      parens (sep [ppr a <> comma,+                   ppr b <> comma,+                   ppr c <> comma,+                   ppr d <> comma,+                   ppr e <> comma,+                   ppr f])++instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) =>+         Outputable (a, b, c, d, e, f, g) where+    ppr (a,b,c,d,e,f,g) =+      parens (sep [ppr a <> comma,+                   ppr b <> comma,+                   ppr c <> comma,+                   ppr d <> comma,+                   ppr e <> comma,+                   ppr f <> comma,+                   ppr g])++instance Outputable FastString where+    ppr fs = ftext fs           -- Prints an unadorned string,+                                -- no double quotes or anything++instance (Outputable key, Outputable elt) => Outputable (M.Map key elt) where+    ppr m = ppr (M.toList m)+instance (Outputable elt) => Outputable (IM.IntMap elt) where+    ppr m = ppr (IM.toList m)++instance Outputable Fingerprint where+    ppr (Fingerprint w1 w2) = text (printf "%016x%016x" w1 w2)++instance Outputable a => Outputable (SCC a) where+   ppr (AcyclicSCC v) = text "NONREC" $$ (nest 3 (ppr v))+   ppr (CyclicSCC vs) = text "REC" $$ (nest 3 (vcat (map ppr vs)))++instance Outputable Serialized where+    ppr (Serialized the_type bytes) = int (length bytes) <+> text "of type" <+> text (show the_type)++instance Outputable Extension where+    ppr = text . show++{-+************************************************************************+*                                                                      *+\subsection{The @OutputableBndr@ class}+*                                                                      *+************************************************************************+-}++-- | '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 GHC.Core.Ppr+data BindingSite+    = LambdaBind  -- ^ The x in   (\x. e)+    | CaseBind    -- ^ The x in   case scrut of x { (y,z) -> ... }+    | CasePatBind -- ^ The y,z in case scrut of x { (y,z) -> ... }+    | LetBind     -- ^ The x in   (let x = rhs in e)++-- | When we print a binder, we often want to print its type too.+-- The @OutputableBndr@ class encapsulates this idea.+class Outputable a => OutputableBndr a where+   pprBndr :: BindingSite -> a -> SDoc+   pprBndr _b x = ppr x++   pprPrefixOcc, pprInfixOcc :: a -> SDoc+      -- Print an occurrence of the name, suitable either in the+      -- prefix position of an application, thus   (f a b) or  ((+) x)+      -- or infix position,                 thus   (a `f` b) or  (x + y)++   bndrIsJoin_maybe :: a -> Maybe Int+   bndrIsJoin_maybe _ = Nothing+      -- When pretty-printing we sometimes want to find+      -- whether the binder is a join point.  You might think+      -- we could have a function of type (a->Var), but Var+      -- isn't available yet, alas++{-+************************************************************************+*                                                                      *+\subsection{Random printing helpers}+*                                                                      *+************************************************************************+-}++-- We have 31-bit Chars and will simply use Show instances of Char and String.++-- | Special combinator for showing character literals.+pprHsChar :: Char -> SDoc+pprHsChar c | c > '\x10ffff' = char '\\' <> text (show (fromIntegral (ord c) :: Word32))+            | otherwise      = text (show c)++-- | Special combinator for showing string literals.+pprHsString :: FastString -> SDoc+pprHsString fs = vcat (map text (showMultiLineString (unpackFS fs)))++-- | Special combinator for showing bytestring literals.+pprHsBytes :: ByteString -> SDoc+pprHsBytes bs = let escaped = concatMap escape $ BS.unpack bs+                in vcat (map text (showMultiLineString escaped)) <> char '#'+    where escape :: Word8 -> String+          escape w = let c = chr (fromIntegral w)+                     in if isAscii c+                        then [c]+                        else '\\' : show w++-- Postfix modifiers for unboxed literals.+-- See Note [Printing of literals in Core] in `basicTypes/Literal.hs`.+primCharSuffix, primFloatSuffix, primIntSuffix :: SDoc+primDoubleSuffix, primWordSuffix, primInt64Suffix, primWord64Suffix :: SDoc+primCharSuffix   = char '#'+primFloatSuffix  = char '#'+primIntSuffix    = char '#'+primDoubleSuffix = text "##"+primWordSuffix   = text "##"+primInt64Suffix  = text "L#"+primWord64Suffix = text "L##"++-- | Special combinator for showing unboxed literals.+pprPrimChar :: Char -> SDoc+pprPrimInt, pprPrimWord, pprPrimInt64, pprPrimWord64 :: Integer -> SDoc+pprPrimChar c   = pprHsChar c <> primCharSuffix+pprPrimInt i    = integer i   <> primIntSuffix+pprPrimWord w   = word    w   <> primWordSuffix+pprPrimInt64 i  = integer i   <> primInt64Suffix+pprPrimWord64 w = word    w   <> primWord64Suffix++---------------------+-- Put a name in parens if it's an operator+pprPrefixVar :: Bool -> SDoc -> SDoc+pprPrefixVar is_operator pp_v+  | is_operator = parens pp_v+  | otherwise   = pp_v++-- Put a name in backquotes if it's not an operator+pprInfixVar :: Bool -> SDoc -> SDoc+pprInfixVar is_operator pp_v+  | is_operator = pp_v+  | otherwise   = char '`' <> pp_v <> char '`'++---------------------+pprFastFilePath :: FastString -> SDoc+pprFastFilePath path = text $ normalise $ unpackFS path++-- | Normalise, escape and render a string representing a path+--+-- e.g. "c:\\whatever"+pprFilePathString :: FilePath -> SDoc+pprFilePathString path = doubleQuotes $ text (escape (normalise path))+   where+      escape []        = []+      escape ('\\':xs) = '\\':'\\':escape xs+      escape (x:xs)    = x:escape xs++{-+************************************************************************+*                                                                      *+\subsection{Other helper functions}+*                                                                      *+************************************************************************+-}++pprWithCommas :: (a -> SDoc) -- ^ The pretty printing function to use+              -> [a]         -- ^ The things to be pretty printed+              -> SDoc        -- ^ 'SDoc' where the things have been pretty printed,+                             -- comma-separated and finally packed into a paragraph.+pprWithCommas pp xs = fsep (punctuate comma (map pp xs))++pprWithBars :: (a -> SDoc) -- ^ The pretty printing function to use+            -> [a]         -- ^ The things to be pretty printed+            -> SDoc        -- ^ 'SDoc' where the things have been pretty printed,+                           -- bar-separated and finally packed into a paragraph.+pprWithBars pp xs = fsep (intersperse vbar (map pp xs))++-- | Returns the separated concatenation of the pretty printed things.+interppSP  :: Outputable a => [a] -> SDoc+interppSP  xs = sep (map ppr xs)++-- | Returns the comma-separated concatenation of the pretty printed things.+interpp'SP :: Outputable a => [a] -> SDoc+interpp'SP xs = sep (punctuate comma (map ppr xs))++-- | Returns the comma-separated concatenation of the quoted pretty printed things.+--+-- > [x,y,z]  ==>  `x', `y', `z'+pprQuotedList :: Outputable a => [a] -> SDoc+pprQuotedList = quotedList . map ppr++quotedList :: [SDoc] -> SDoc+quotedList xs = fsep (punctuate comma (map quotes xs))++quotedListWithOr :: [SDoc] -> SDoc+-- [x,y,z]  ==>  `x', `y' or `z'+quotedListWithOr xs@(_:_:_) = quotedList (init xs) <+> text "or" <+> quotes (last xs)+quotedListWithOr xs = quotedList xs++quotedListWithNor :: [SDoc] -> SDoc+-- [x,y,z]  ==>  `x', `y' nor `z'+quotedListWithNor xs@(_:_:_) = quotedList (init xs) <+> text "nor" <+> quotes (last xs)+quotedListWithNor xs = quotedList xs++{-+************************************************************************+*                                                                      *+\subsection{Printing numbers verbally}+*                                                                      *+************************************************************************+-}++intWithCommas :: Integral a => a -> SDoc+-- Prints a big integer with commas, eg 345,821+intWithCommas n+  | n < 0     = char '-' <> intWithCommas (-n)+  | q == 0    = int (fromIntegral r)+  | otherwise = intWithCommas q <> comma <> zeroes <> int (fromIntegral r)+  where+    (q,r) = n `quotRem` 1000+    zeroes | r >= 100  = empty+           | r >= 10   = char '0'+           | otherwise = text "00"++-- | Converts an integer to a verbal index:+--+-- > speakNth 1 = text "first"+-- > speakNth 5 = text "fifth"+-- > speakNth 21 = text "21st"+speakNth :: Int -> SDoc+speakNth 1 = text "first"+speakNth 2 = text "second"+speakNth 3 = text "third"+speakNth 4 = text "fourth"+speakNth 5 = text "fifth"+speakNth 6 = text "sixth"+speakNth n = hcat [ int n, text suffix ]+  where+    suffix | n <= 20       = "th"       -- 11,12,13 are non-std+           | last_dig == 1 = "st"+           | last_dig == 2 = "nd"+           | last_dig == 3 = "rd"+           | otherwise     = "th"++    last_dig = n `rem` 10++-- | Converts an integer to a verbal multiplicity:+--+-- > speakN 0 = text "none"+-- > speakN 5 = text "five"+-- > speakN 10 = text "10"+speakN :: Int -> SDoc+speakN 0 = text "none"  -- E.g.  "he has none"+speakN 1 = text "one"   -- E.g.  "he has one"+speakN 2 = text "two"+speakN 3 = text "three"+speakN 4 = text "four"+speakN 5 = text "five"+speakN 6 = text "six"+speakN n = int n++-- | Converts an integer and object description to a statement about the+-- multiplicity of those objects:+--+-- > speakNOf 0 (text "melon") = text "no melons"+-- > speakNOf 1 (text "melon") = text "one melon"+-- > speakNOf 3 (text "melon") = text "three melons"+speakNOf :: Int -> SDoc -> SDoc+speakNOf 0 d = text "no" <+> d <> char 's'+speakNOf 1 d = text "one" <+> d                 -- E.g. "one argument"+speakNOf n d = speakN n <+> d <> char 's'               -- E.g. "three arguments"++-- | Determines the pluralisation suffix appropriate for the length of a list:+--+-- > plural [] = char 's'+-- > plural ["Hello"] = empty+-- > plural ["Hello", "World"] = char 's'+plural :: [a] -> SDoc+plural [_] = empty  -- a bit frightening, but there you are+plural _   = char 's'++-- | Determines the form of to be appropriate for the length of a list:+--+-- > isOrAre [] = text "are"+-- > isOrAre ["Hello"] = text "is"+-- > isOrAre ["Hello", "World"] = text "are"+isOrAre :: [a] -> SDoc+isOrAre [_] = text "is"+isOrAre _   = text "are"++-- | Determines the form of to do appropriate for the length of a list:+--+-- > doOrDoes [] = text "do"+-- > doOrDoes ["Hello"] = text "does"+-- > doOrDoes ["Hello", "World"] = text "do"+doOrDoes :: [a] -> SDoc+doOrDoes [_] = text "does"+doOrDoes _   = text "do"++-- | Determines the form of possessive appropriate for the length of a list:+--+-- > itsOrTheir [x]   = text "its"+-- > itsOrTheir [x,y] = text "their"+-- > itsOrTheir []    = text "their"  -- probably avoid this+itsOrTheir :: [a] -> SDoc+itsOrTheir [_] = text "its"+itsOrTheir _   = text "their"++{-+************************************************************************+*                                                                      *+\subsection{Error handling}+*                                                                      *+************************************************************************+-}++callStackDoc :: HasCallStack => SDoc+callStackDoc =+    hang (text "Call stack:")+       4 (vcat $ map text $ lines (prettyCallStack callStack))++pprPanic :: HasCallStack => String -> SDoc -> a+-- ^ Throw an exception saying "bug in GHC"+pprPanic s doc = panicDoc s (doc $$ callStackDoc)++pprSorry :: String -> SDoc -> a+-- ^ Throw an exception saying "this isn't finished yet"+pprSorry    = sorryDoc+++pprPgmError :: String -> SDoc -> a+-- ^ Throw an exception saying "bug in pgm being compiled" (used for unusual program errors)+pprPgmError = pgmErrorDoc++pprTraceDebug :: String -> SDoc -> a -> a+pprTraceDebug str doc x+   | debugIsOn && hasPprDebug unsafeGlobalDynFlags = pprTrace str doc x+   | otherwise                                     = x++-- | If debug output is on, show some 'SDoc' on the screen+pprTrace :: String -> SDoc -> a -> a+pprTrace str doc x = pprTraceWithFlags unsafeGlobalDynFlags str doc x++-- | If debug output is on, show some 'SDoc' on the screen+pprTraceWithFlags :: DynFlags -> String -> SDoc -> a -> a+pprTraceWithFlags dflags str doc x+  | hasNoDebugOutput dflags = x+  | otherwise               = pprDebugAndThen dflags trace (text str) doc x++pprTraceM :: Applicative f => String -> SDoc -> f ()+pprTraceM str doc = pprTrace str doc (pure ())++-- | @pprTraceWith desc f x@ is equivalent to @pprTrace desc (f x) x@.+-- This allows you to print details from the returned value as well as from+-- ambient variables.+pprTraceWith :: String -> (a -> SDoc) -> a -> a+pprTraceWith desc f x = pprTrace desc (f x) x++-- | @pprTraceIt desc x@ is equivalent to @pprTrace desc (ppr x) x@+pprTraceIt :: Outputable a => String -> a -> a+pprTraceIt desc x = pprTraceWith desc ppr x++-- | @pprTraceException desc x action@ runs action, printing a message+-- if it throws an exception.+pprTraceException :: ExceptionMonad m => String -> SDoc -> m a -> m a+pprTraceException heading doc =+    handleGhcException $ \exc -> liftIO $ do+        putStrLn $ showSDocDump unsafeGlobalDynFlags (sep [text heading, nest 2 doc])+        throwGhcExceptionIO exc++-- | If debug output is on, show some 'SDoc' on the screen along+-- with a call stack when available.+pprSTrace :: HasCallStack => SDoc -> a -> a+pprSTrace doc = pprTrace "" (doc $$ callStackDoc)++warnPprTrace :: HasCallStack => Bool -> String -> Int -> SDoc -> a -> a+-- ^ Just warn about an assertion failure, recording the given file and line number.+-- Should typically be accessed with the WARN macros+warnPprTrace _     _     _     _    x | not debugIsOn     = x+warnPprTrace _     _file _line _msg x+   | hasNoDebugOutput unsafeGlobalDynFlags = x+warnPprTrace False _file _line _msg x = x+warnPprTrace True   file  line  msg x+  = pprDebugAndThen unsafeGlobalDynFlags trace heading+                    (msg $$ callStackDoc )+                    x+  where+    heading = hsep [text "WARNING: file", text file <> comma, text "line", int line]++-- | Panic with an assertion failure, recording the given file and+-- line number. Should typically be accessed with the ASSERT family of macros+assertPprPanic :: HasCallStack => String -> Int -> SDoc -> a+assertPprPanic _file _line msg+  = pprPanic "ASSERT failed!" msg++pprDebugAndThen :: DynFlags -> (String -> a) -> SDoc -> SDoc -> a+pprDebugAndThen dflags cont heading pretty_msg+ = cont (showSDocDump dflags doc)+ where+     doc = sep [heading, nest 2 pretty_msg]
+ compiler/GHC/Utils/Outputable.hs-boot view
@@ -0,0 +1,14 @@+module GHC.Utils.Outputable where++import GHC.Prelude+import GHC.Stack( HasCallStack )++data SDoc+data PprStyle+data SDocContext++showSDocUnsafe :: SDoc -> String++warnPprTrace :: HasCallStack => Bool -> String -> Int -> SDoc -> a -> a++text :: String -> SDoc
+ compiler/GHC/Utils/Panic.hs view
@@ -0,0 +1,259 @@+{-+(c) The University of Glasgow 2006+(c) The GRASP Project, Glasgow University, 1992-2000++-}++{-# LANGUAGE CPP, ScopedTypeVariables, LambdaCase #-}++-- | Defines basic functions for printing error messages.+--+-- It's hard to put these functions anywhere else without causing+-- some unnecessary loops in the module dependency graph.+module GHC.Utils.Panic (+     GhcException(..), showGhcException,+     throwGhcException, throwGhcExceptionIO,+     handleGhcException,+     GHC.Utils.Panic.Plain.progName,+     pgmError,++     panic, sorry, assertPanic, trace,+     panicDoc, sorryDoc, pgmErrorDoc,++     cmdLineError, cmdLineErrorIO,++     Exception.Exception(..), showException, safeShowException,+     try, tryMost, throwTo,++     withSignalHandlers,+) where++import GHC.Prelude++import {-# SOURCE #-} GHC.Utils.Outputable (SDoc, showSDocUnsafe)+import GHC.Utils.Panic.Plain++import GHC.Utils.Exception as Exception++import Control.Monad.IO.Class+import Control.Concurrent+import Data.Typeable      ( cast )+import Debug.Trace        ( trace )+import System.IO.Unsafe++#if !defined(mingw32_HOST_OS)+import System.Posix.Signals as S+#endif++#if defined(mingw32_HOST_OS)+import GHC.ConsoleHandler as S+#endif++import System.Mem.Weak  ( deRefWeak )++-- | GHC's own exception type+--   error messages all take the form:+--+--  @+--      <location>: <error>+--  @+--+--   If the location is on the command line, or in GHC itself, then+--   <location>="ghc".  All of the error types below correspond to+--   a <location> of "ghc", except for ProgramError (where the string is+--  assumed to contain a location already, so we don't print one).++data GhcException+  -- | Some other fatal signal (SIGHUP,SIGTERM)+  = Signal Int++  -- | Prints the short usage msg after the error+  | UsageError   String++  -- | A problem with the command line arguments, but don't print usage.+  | CmdLineError String++  -- | The 'impossible' happened.+  | Panic        String+  | PprPanic     String SDoc++  -- | The user tickled something that's known not to work yet,+  --   but we're not counting it as a bug.+  | Sorry        String+  | PprSorry     String SDoc++  -- | An installation problem.+  | InstallationError String++  -- | An error in the user's code, probably.+  | ProgramError    String+  | PprProgramError String SDoc++instance Exception GhcException where+  fromException (SomeException e)+    | Just ge <- cast e = Just ge+    | Just pge <- cast e = Just $+        case pge of+          PlainSignal n -> Signal n+          PlainUsageError str -> UsageError str+          PlainCmdLineError str -> CmdLineError str+          PlainPanic str -> Panic str+          PlainSorry str -> Sorry str+          PlainInstallationError str -> InstallationError str+          PlainProgramError str -> ProgramError str+    | otherwise = Nothing++instance Show GhcException where+  showsPrec _ e@(ProgramError _) = showGhcException e+  showsPrec _ e@(CmdLineError _) = showString "<command line>: " . showGhcException e+  showsPrec _ e = showString progName . showString ": " . showGhcException e++-- | Show an exception as a string.+showException :: Exception e => e -> String+showException = show++-- | Show an exception which can possibly throw other exceptions.+-- Used when displaying exception thrown within TH code.+safeShowException :: Exception e => e -> IO String+safeShowException e = do+    -- ensure the whole error message is evaluated inside try+    r <- try (return $! forceList (showException e))+    case r of+        Right msg -> return msg+        Left e' -> safeShowException (e' :: SomeException)+    where+        forceList [] = []+        forceList xs@(x : xt) = x `seq` forceList xt `seq` xs++-- | Append a description of the given exception to this string.+--+-- Note that this uses 'DynFlags.unsafeGlobalDynFlags', which may have some+-- uninitialized fields if invoked before 'GHC.initGhcMonad' has been called.+-- If the error message to be printed includes a pretty-printer document+-- which forces one of these fields this call may bottom.+showGhcException :: GhcException -> ShowS+showGhcException = showPlainGhcException . \case+  Signal n -> PlainSignal n+  UsageError str -> PlainUsageError str+  CmdLineError str -> PlainCmdLineError str+  Panic str -> PlainPanic str+  Sorry str -> PlainSorry str+  InstallationError str -> PlainInstallationError str+  ProgramError str -> PlainProgramError str++  PprPanic str sdoc -> PlainPanic $+      concat [str, "\n\n", showSDocUnsafe sdoc]+  PprSorry str sdoc -> PlainProgramError $+      concat [str, "\n\n", showSDocUnsafe sdoc]+  PprProgramError str sdoc -> PlainProgramError $+      concat [str, "\n\n", showSDocUnsafe sdoc]++throwGhcException :: GhcException -> a+throwGhcException = Exception.throw++throwGhcExceptionIO :: GhcException -> IO a+throwGhcExceptionIO = Exception.throwIO++handleGhcException :: ExceptionMonad m => (GhcException -> m a) -> m a -> m a+handleGhcException = ghandle++panicDoc, sorryDoc, pgmErrorDoc :: String -> SDoc -> a+panicDoc    x doc = throwGhcException (PprPanic        x doc)+sorryDoc    x doc = throwGhcException (PprSorry        x doc)+pgmErrorDoc x doc = throwGhcException (PprProgramError x doc)++-- | Like try, but pass through UserInterrupt and Panic exceptions.+--   Used when we want soft failures when reading interface files, for example.+--   TODO: I'm not entirely sure if this is catching what we really want to catch+tryMost :: IO a -> IO (Either SomeException a)+tryMost action = do r <- try action+                    case r of+                        Left se ->+                            case fromException se of+                                -- Some GhcException's we rethrow,+                                Just (Signal _)  -> throwIO se+                                Just (Panic _)   -> throwIO se+                                -- others we return+                                Just _           -> return (Left se)+                                Nothing ->+                                    case fromException se of+                                        -- All IOExceptions are returned+                                        Just (_ :: IOException) ->+                                            return (Left se)+                                        -- Anything else is rethrown+                                        Nothing -> throwIO se+                        Right v -> return (Right v)++-- | We use reference counting for signal handlers+{-# NOINLINE signalHandlersRefCount #-}+#if !defined(mingw32_HOST_OS)+signalHandlersRefCount :: MVar (Word, Maybe (S.Handler,S.Handler+                                            ,S.Handler,S.Handler))+#else+signalHandlersRefCount :: MVar (Word, Maybe S.Handler)+#endif+signalHandlersRefCount = unsafePerformIO $ newMVar (0,Nothing)+++-- | Temporarily install standard signal handlers for catching ^C, which just+-- throw an exception in the current thread.+withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a+withSignalHandlers act = do+  main_thread <- liftIO myThreadId+  wtid <- liftIO (mkWeakThreadId main_thread)++  let+      interrupt = do+        r <- deRefWeak wtid+        case r of+          Nothing -> return ()+          Just t  -> throwTo t UserInterrupt++#if !defined(mingw32_HOST_OS)+  let installHandlers = do+        let installHandler' a b = installHandler a b Nothing+        hdlQUIT <- installHandler' sigQUIT  (Catch interrupt)+        hdlINT  <- installHandler' sigINT   (Catch interrupt)+        -- see #3656; in the future we should install these automatically for+        -- all Haskell programs in the same way that we install a ^C handler.+        let fatal_signal n = throwTo main_thread (Signal (fromIntegral n))+        hdlHUP  <- installHandler' sigHUP   (Catch (fatal_signal sigHUP))+        hdlTERM <- installHandler' sigTERM  (Catch (fatal_signal sigTERM))+        return (hdlQUIT,hdlINT,hdlHUP,hdlTERM)++  let uninstallHandlers (hdlQUIT,hdlINT,hdlHUP,hdlTERM) = do+        _ <- installHandler sigQUIT  hdlQUIT Nothing+        _ <- installHandler sigINT   hdlINT  Nothing+        _ <- installHandler sigHUP   hdlHUP  Nothing+        _ <- installHandler sigTERM  hdlTERM Nothing+        return ()+#else+  -- GHC 6.3+ has support for console events on Windows+  -- NOTE: running GHCi under a bash shell for some reason requires+  -- you to press Ctrl-Break rather than Ctrl-C to provoke+  -- an interrupt.  Ctrl-C is getting blocked somewhere, I don't know+  -- why --SDM 17/12/2004+  let sig_handler ControlC = interrupt+      sig_handler Break    = interrupt+      sig_handler _        = return ()++  let installHandlers   = installHandler (Catch sig_handler)+  let uninstallHandlers = installHandler -- directly install the old handler+#endif++  -- install signal handlers if necessary+  let mayInstallHandlers = liftIO $ modifyMVar_ signalHandlersRefCount $ \case+        (0,Nothing)     -> do+          hdls <- installHandlers+          return (1,Just hdls)+        (c,oldHandlers) -> return (c+1,oldHandlers)++  -- uninstall handlers if necessary+  let mayUninstallHandlers = liftIO $ modifyMVar_ signalHandlersRefCount $ \case+        (1,Just hdls)   -> do+          _ <- uninstallHandlers hdls+          return (0,Nothing)+        (c,oldHandlers) -> return (c-1,oldHandlers)++  mayInstallHandlers+  act `gfinally` mayUninstallHandlers
+ compiler/GHC/Utils/Panic/Plain.hs view
@@ -0,0 +1,138 @@+{-# LANGUAGE CPP, ScopedTypeVariables, LambdaCase #-}++-- | Defines a simple exception type and utilities to throw it. The+-- 'PlainGhcException' type is a subset of the 'Panic.GhcException'+-- type.  It omits the exception constructors that involve+-- pretty-printing via 'Outputable.SDoc'.+--+-- There are two reasons for this:+--+-- 1. To avoid import cycles / use of boot files. "Outputable" has+-- many transitive dependencies. To throw exceptions from these+-- modules, the functions here can be used without introducing import+-- cycles.+--+-- 2. To reduce the number of modules that need to be compiled to+-- object code when loading GHC into GHCi. See #13101+module GHC.Utils.Panic.Plain+  ( PlainGhcException(..)+  , showPlainGhcException++  , panic, sorry, pgmError+  , cmdLineError, cmdLineErrorIO+  , assertPanic++  , progName+  ) where++#include "HsVersions.h"++import Config+import GHC.Utils.Exception as Exception+import GHC.Stack+import GHC.Prelude+import System.Environment+import System.IO.Unsafe++-- | This type is very similar to 'Panic.GhcException', but it omits+-- the constructors that involve pretty-printing via+-- 'Outputable.SDoc'.  Due to the implementation of 'fromException'+-- for 'Panic.GhcException', this type can be caught as a+-- 'Panic.GhcException'.+--+-- Note that this should only be used for throwing exceptions, not for+-- catching, as 'Panic.GhcException' will not be converted to this+-- type when catching.+data PlainGhcException+  -- | Some other fatal signal (SIGHUP,SIGTERM)+  = PlainSignal Int++  -- | Prints the short usage msg after the error+  | PlainUsageError        String++  -- | A problem with the command line arguments, but don't print usage.+  | PlainCmdLineError      String++  -- | The 'impossible' happened.+  | PlainPanic             String++  -- | The user tickled something that's known not to work yet,+  --   but we're not counting it as a bug.+  | PlainSorry             String++  -- | An installation problem.+  | PlainInstallationError String++  -- | An error in the user's code, probably.+  | PlainProgramError      String++instance Exception PlainGhcException++instance Show PlainGhcException where+  showsPrec _ e@(PlainProgramError _) = showPlainGhcException e+  showsPrec _ e@(PlainCmdLineError _) = showString "<command line>: " . showPlainGhcException e+  showsPrec _ e = showString progName . showString ": " . showPlainGhcException e++-- | The name of this GHC.+progName :: String+progName = unsafePerformIO (getProgName)+{-# NOINLINE progName #-}++-- | Short usage information to display when we are given the wrong cmd line arguments.+short_usage :: String+short_usage = "Usage: For basic information, try the `--help' option."++-- | Append a description of the given exception to this string.+showPlainGhcException :: PlainGhcException -> ShowS+showPlainGhcException =+  \case+    PlainSignal n -> showString "signal: " . shows n+    PlainUsageError str -> showString str . showChar '\n' . showString short_usage+    PlainCmdLineError str -> showString str+    PlainPanic s -> panicMsg (showString s)+    PlainSorry s -> sorryMsg (showString s)+    PlainInstallationError str -> showString str+    PlainProgramError str -> showString str+  where+    sorryMsg :: ShowS -> ShowS+    sorryMsg s =+        showString "sorry! (unimplemented feature or known bug)\n"+      . showString ("  (GHC version " ++ cProjectVersion ++ ":\n\t")+      . s . showString "\n"++    panicMsg :: ShowS -> ShowS+    panicMsg s =+        showString "panic! (the 'impossible' happened)\n"+      . showString ("  (GHC version " ++ cProjectVersion ++ ":\n\t")+      . s . showString "\n\n"+      . showString "Please report this as a GHC bug:  https://www.haskell.org/ghc/reportabug\n"++throwPlainGhcException :: PlainGhcException -> a+throwPlainGhcException = Exception.throw++-- | Panics and asserts.+panic, sorry, pgmError :: String -> a+panic    x = unsafeDupablePerformIO $ do+   stack <- ccsToStrings =<< getCurrentCCS x+   if null stack+      then throwPlainGhcException (PlainPanic x)+      else throwPlainGhcException (PlainPanic (x ++ '\n' : renderStack stack))++sorry    x = throwPlainGhcException (PlainSorry x)+pgmError x = throwPlainGhcException (PlainProgramError x)++cmdLineError :: String -> a+cmdLineError = unsafeDupablePerformIO . cmdLineErrorIO++cmdLineErrorIO :: String -> IO a+cmdLineErrorIO x = do+  stack <- ccsToStrings =<< getCurrentCCS x+  if null stack+    then throwPlainGhcException (PlainCmdLineError x)+    else throwPlainGhcException (PlainCmdLineError (x ++ '\n' : renderStack stack))++-- | Throw a failed assertion exception for a given filename and line number.+assertPanic :: String -> Int -> a+assertPanic file line =+  Exception.throw (Exception.AssertionFailed+           ("ASSERT failed! file " ++ file ++ ", line " ++ show line))
+ compiler/GHC/Utils/Ppr.hs view
@@ -0,0 +1,1105 @@+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE MagicHash #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  GHC.Utils.Ppr+-- Copyright   :  (c) The University of Glasgow 2001+-- License     :  BSD-style (see the file LICENSE)+--+-- Maintainer  :  David Terei <code@davidterei.com>+-- Stability   :  stable+-- Portability :  portable+--+-- John Hughes's and Simon Peyton Jones's Pretty Printer Combinators+--+-- Based on /The Design of a Pretty-printing Library/+-- in Advanced Functional Programming,+-- Johan Jeuring and Erik Meijer (eds), LNCS 925+-- <http://www.cs.chalmers.se/~rjmh/Papers/pretty.ps>+--+-----------------------------------------------------------------------------++{-+Note [Differences between libraries/pretty and compiler/utils/Pretty.hs]++For historical reasons, there are two different copies of `Pretty` in the GHC+source tree:+ * `libraries/pretty` is a submodule containing+   https://github.com/haskell/pretty. This is the `pretty` library as released+   on hackage. It is used by several other libraries in the GHC source tree+   (e.g. template-haskell and Cabal).+ * `compiler/utils/Pretty.hs` (this module). It is used by GHC only.++There is an ongoing effort in https://github.com/haskell/pretty/issues/1 and+https://gitlab.haskell.org/ghc/ghc/issues/10735 to try to get rid of GHC's copy+of Pretty.++Currently, GHC's copy of Pretty resembles pretty-1.1.2.0, with the following+major differences:+ * GHC's copy uses `Faststring` for performance reasons.+ * GHC's copy has received a backported bugfix for #12227, which was+   released as pretty-1.1.3.4 ("Remove harmful $! forcing in beside",+   https://github.com/haskell/pretty/pull/35).++Other differences are minor. Both copies define some extra functions and+instances not defined in the other copy. To see all differences, do this in a+ghc git tree:++    $ cd libraries/pretty+    $ git checkout v1.1.2.0+    $ cd -+    $ vimdiff compiler/utils/Pretty.hs \+              libraries/pretty/src/Text/PrettyPrint/HughesPJ.hs++For parity with `pretty-1.1.2.1`, the following two `pretty` commits would+have to be backported:+  * "Resolve foldr-strictness stack overflow bug"+    (307b8173f41cd776eae8f547267df6d72bff2d68)+  * "Special-case reduce for horiz/vert"+    (c57c7a9dfc49617ba8d6e4fcdb019a3f29f1044c)+This has not been done sofar, because these commits seem to cause more+allocation in the compiler (see thomie's comments in+https://github.com/haskell/pretty/pull/9).+-}++module GHC.Utils.Ppr (++        -- * The document type+        Doc, TextDetails(..),++        -- * Constructing documents++        -- ** Converting values into documents+        char, text, ftext, ptext, ztext, sizedText, zeroWidthText,+        int, integer, float, double, rational, hex,++        -- ** Simple derived documents+        semi, comma, colon, space, equals,+        lparen, rparen, lbrack, rbrack, lbrace, rbrace,++        -- ** Wrapping documents in delimiters+        parens, brackets, braces, quotes, quote, doubleQuotes,+        maybeParens,++        -- ** Combining documents+        empty,+        (<>), (<+>), hcat, hsep,+        ($$), ($+$), vcat,+        sep, cat,+        fsep, fcat,+        nest,+        hang, hangNotEmpty, punctuate,++        -- * Predicates on documents+        isEmpty,++        -- * Rendering documents++        -- ** Rendering with a particular style+        Style(..),+        style,+        renderStyle,+        Mode(..),++        -- ** General rendering+        fullRender, txtPrinter,++        -- ** GHC-specific rendering+        printDoc, printDoc_,+        bufLeftRender -- performance hack++  ) where++import GHC.Prelude hiding (error)++import GHC.Utils.BufHandle+import GHC.Data.FastString+import GHC.Utils.Panic.Plain+import System.IO+import Numeric (showHex)++--for a RULES+import GHC.Base ( unpackCString#, unpackNBytes#, Int(..) )+import GHC.Ptr  ( Ptr(..) )++-- ---------------------------------------------------------------------------+-- The Doc calculus++{-+Laws for $$+~~~~~~~~~~~+<a1>    (x $$ y) $$ z   = x $$ (y $$ z)+<a2>    empty $$ x      = x+<a3>    x $$ empty      = x++        ...ditto $+$...++Laws for <>+~~~~~~~~~~~+<b1>    (x <> y) <> z   = x <> (y <> z)+<b2>    empty <> x      = empty+<b3>    x <> empty      = x++        ...ditto <+>...++Laws for text+~~~~~~~~~~~~~+<t1>    text s <> text t        = text (s++t)+<t2>    text "" <> x            = x, if x non-empty++** because of law n6, t2 only holds if x doesn't+** start with `nest'.+++Laws for nest+~~~~~~~~~~~~~+<n1>    nest 0 x                = x+<n2>    nest k (nest k' x)      = nest (k+k') x+<n3>    nest k (x <> y)         = nest k x <> nest k y+<n4>    nest k (x $$ y)         = nest k x $$ nest k y+<n5>    nest k empty            = empty+<n6>    x <> nest k y           = x <> y, if x non-empty++** Note the side condition on <n6>!  It is this that+** makes it OK for empty to be a left unit for <>.++Miscellaneous+~~~~~~~~~~~~~+<m1>    (text s <> x) $$ y = text s <> ((text "" <> x) $$+                                         nest (-length s) y)++<m2>    (x $$ y) <> z = x $$ (y <> z)+        if y non-empty+++Laws for list versions+~~~~~~~~~~~~~~~~~~~~~~+<l1>    sep (ps++[empty]++qs)   = sep (ps ++ qs)+        ...ditto hsep, hcat, vcat, fill...++<l2>    nest k (sep ps) = sep (map (nest k) ps)+        ...ditto hsep, hcat, vcat, fill...++Laws for oneLiner+~~~~~~~~~~~~~~~~~+<o1>    oneLiner (nest k p) = nest k (oneLiner p)+<o2>    oneLiner (x <> y)   = oneLiner x <> oneLiner y++You might think that the following version of <m1> would+be neater:++<3 NO>  (text s <> x) $$ y = text s <> ((empty <> x)) $$+                                         nest (-length s) y)++But it doesn't work, for if x=empty, we would have++        text s $$ y = text s <> (empty $$ nest (-length s) y)+                    = text s <> nest (-length s) y+-}++-- ---------------------------------------------------------------------------+-- Operator fixity++infixl 6 <>+infixl 6 <+>+infixl 5 $$, $+$+++-- ---------------------------------------------------------------------------+-- The Doc data type++-- | The abstract type of documents.+-- A Doc represents a *set* of layouts. A Doc with+-- no occurrences of Union or NoDoc represents just one layout.+data Doc+  = Empty                                            -- empty+  | NilAbove Doc                                     -- text "" $$ x+  | TextBeside !TextDetails {-# UNPACK #-} !Int Doc  -- text s <> x+  | Nest {-# UNPACK #-} !Int Doc                     -- nest k x+  | Union Doc Doc                                    -- ul `union` ur+  | NoDoc                                            -- The empty set of documents+  | Beside Doc Bool Doc                              -- True <=> space between+  | Above Doc Bool Doc                               -- True <=> never overlap++{-+Here are the invariants:++1) The argument of NilAbove is never Empty. Therefore+   a NilAbove occupies at least two lines.++2) The argument of @TextBeside@ is never @Nest@.++3) The layouts of the two arguments of @Union@ both flatten to the same+   string.++4) The arguments of @Union@ are either @TextBeside@, or @NilAbove@.++5) A @NoDoc@ may only appear on the first line of the left argument of an+   union. Therefore, the right argument of an union can never be equivalent+   to the empty set (@NoDoc@).++6) An empty document is always represented by @Empty@.  It can't be+   hidden inside a @Nest@, or a @Union@ of two @Empty@s.++7) The first line of every layout in the left argument of @Union@ is+   longer than the first line of any layout in the right argument.+   (1) ensures that the left argument has a first line.  In view of+   (3), this invariant means that the right argument must have at+   least two lines.++Notice the difference between+   * NoDoc (no documents)+   * Empty (one empty document; no height and no width)+   * text "" (a document containing the empty string;+              one line high, but has no width)+-}+++-- | RDoc is a "reduced GDoc", guaranteed not to have a top-level Above or Beside.+type RDoc = Doc++-- | The TextDetails data type+--+-- A TextDetails represents a fragment of text that will be+-- output at some point.+data TextDetails = Chr  {-# UNPACK #-} !Char -- ^ A single Char fragment+                 | Str  String -- ^ A whole String fragment+                 | PStr FastString                      -- a hashed string+                 | ZStr FastZString                     -- a z-encoded string+                 | LStr {-# UNPACK #-} !PtrString+                   -- a '\0'-terminated array of bytes+                 | RStr {-# UNPACK #-} !Int {-# UNPACK #-} !Char+                   -- a repeated character (e.g., ' ')++instance Show Doc where+  showsPrec _ doc cont = fullRender (mode style) (lineLength style)+                                    (ribbonsPerLine style)+                                    txtPrinter cont doc+++-- ---------------------------------------------------------------------------+-- Values and Predicates on GDocs and TextDetails++-- | A document of height and width 1, containing a literal character.+char :: Char -> Doc+char c = textBeside_ (Chr c) 1 Empty++-- | A document of height 1 containing a literal string.+-- 'text' satisfies the following laws:+--+-- * @'text' s '<>' 'text' t = 'text' (s'++'t)@+--+-- * @'text' \"\" '<>' x = x@, if @x@ non-empty+--+-- The side condition on the last law is necessary because @'text' \"\"@+-- has height 1, while 'empty' has no height.+text :: String -> Doc+text s = textBeside_ (Str s) (length s) Empty+{-# NOINLINE [0] text #-}   -- Give the RULE a chance to fire+                            -- It must wait till after phase 1 when+                            -- the unpackCString first is manifested++-- RULE that turns (text "abc") into (ptext (A# "abc"#)) to avoid the+-- intermediate packing/unpacking of the string.+{-# RULES "text/str"+    forall a. text (unpackCString# a)  = ptext (mkPtrString# a)+  #-}+{-# RULES "text/unpackNBytes#"+    forall p n. text (unpackNBytes# p n) = ptext (PtrString (Ptr p) (I# n))+  #-}++ftext :: FastString -> Doc+ftext s = textBeside_ (PStr s) (lengthFS s) Empty++ptext :: PtrString -> Doc+ptext s = textBeside_ (LStr s) (lengthPS s) Empty++ztext :: FastZString -> Doc+ztext s = textBeside_ (ZStr s) (lengthFZS s) Empty++-- | Some text with any width. (@text s = sizedText (length s) s@)+sizedText :: Int -> String -> Doc+sizedText l s = textBeside_ (Str s) l Empty++-- | Some text, but without any width. Use for non-printing text+-- such as a HTML or Latex tags+zeroWidthText :: String -> Doc+zeroWidthText = sizedText 0++-- | The empty document, with no height and no width.+-- 'empty' is the identity for '<>', '<+>', '$$' and '$+$', and anywhere+-- in the argument list for 'sep', 'hcat', 'hsep', 'vcat', 'fcat' etc.+empty :: Doc+empty = Empty++-- | Returns 'True' if the document is empty+isEmpty :: Doc -> Bool+isEmpty Empty = True+isEmpty _     = False++{-+Q: What is the reason for negative indentation (i.e. argument to indent+   is < 0) ?++A:+This indicates an error in the library client's code.+If we compose a <> b, and the first line of b is more indented than some+other lines of b, the law <n6> (<> eats nests) may cause the pretty+printer to produce an invalid layout:++doc       |0123345+------------------+d1        |a...|+d2        |...b|+          |c...|++d1<>d2    |ab..|+         c|....|++Consider a <> b, let `s' be the length of the last line of `a', `k' the+indentation of the first line of b, and `k0' the indentation of the+left-most line b_i of b.++The produced layout will have negative indentation if `k - k0 > s', as+the first line of b will be put on the (s+1)th column, effectively+translating b horizontally by (k-s). Now if the i^th line of b has an+indentation k0 < (k-s), it is translated out-of-page, causing+`negative indentation'.+-}+++semi   :: Doc -- ^ A ';' character+comma  :: Doc -- ^ A ',' character+colon  :: Doc -- ^ A ':' character+space  :: Doc -- ^ A space character+equals :: Doc -- ^ A '=' character+lparen :: Doc -- ^ A '(' character+rparen :: Doc -- ^ A ')' character+lbrack :: Doc -- ^ A '[' character+rbrack :: Doc -- ^ A ']' character+lbrace :: Doc -- ^ A '{' character+rbrace :: Doc -- ^ A '}' character+semi   = char ';'+comma  = char ','+colon  = char ':'+space  = char ' '+equals = char '='+lparen = char '('+rparen = char ')'+lbrack = char '['+rbrack = char ']'+lbrace = char '{'+rbrace = char '}'++spaceText, nlText :: TextDetails+spaceText = Chr ' '+nlText    = Chr '\n'++int      :: Int      -> Doc -- ^ @int n = text (show n)@+integer  :: Integer  -> Doc -- ^ @integer n = text (show n)@+float    :: Float    -> Doc -- ^ @float n = text (show n)@+double   :: Double   -> Doc -- ^ @double n = text (show n)@+rational :: Rational -> Doc -- ^ @rational n = text (show n)@+hex      :: Integer  -> Doc -- ^ See Note [Print Hexadecimal Literals]+int      n = text (show n)+integer  n = text (show n)+float    n = text (show n)+double   n = text (show n)+rational n = text (show n)+hex      n = text ('0' : 'x' : padded)+    where+    str = showHex n ""+    strLen = max 1 (length str)+    len = 2 ^ (ceiling (logBase 2 (fromIntegral strLen :: Double)) :: Int)+    padded = replicate (len - strLen) '0' ++ str++parens       :: Doc -> Doc -- ^ Wrap document in @(...)@+brackets     :: Doc -> Doc -- ^ Wrap document in @[...]@+braces       :: Doc -> Doc -- ^ Wrap document in @{...}@+quotes       :: Doc -> Doc -- ^ Wrap document in @\'...\'@+quote        :: Doc -> Doc+doubleQuotes :: Doc -> Doc -- ^ Wrap document in @\"...\"@+quotes p       = char '`' <> p <> char '\''+quote p        = char '\'' <> p+doubleQuotes p = char '"' <> p <> char '"'+parens p       = char '(' <> p <> char ')'+brackets p     = char '[' <> p <> char ']'+braces p       = char '{' <> p <> char '}'++{-+Note [Print Hexadecimal Literals]++Relevant discussions:+ * Phabricator: https://phabricator.haskell.org/D4465+ * GHC Trac: https://gitlab.haskell.org/ghc/ghc/issues/14872++There is a flag `-dword-hex-literals` that causes literals of+type `Word#` or `Word64#` to be displayed in hexadecimal instead+of decimal when dumping GHC core. It also affects the presentation+of these in GHC's error messages. Additionally, the hexadecimal+encoding of these numbers is zero-padded so that its length is+a power of two. As an example of what this does,+consider the following haskell file `Literals.hs`:++    module Literals where++    alpha :: Int+    alpha = 100 + 200++    beta :: Word -> Word+    beta x = x + div maxBound 255 + div 0xFFFFFFFF 255 + 0x0202++We get the following dumped core when we compile on a 64-bit+machine with ghc -O2 -fforce-recomp -ddump-simpl -dsuppress-all+-dhex-word-literals literals.hs:++    ==================== Tidy Core ====================++    ... omitted for brevity ...++    -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}+    alpha+    alpha = I# 300#++    -- RHS size: {terms: 12, types: 3, coercions: 0, joins: 0/0}+    beta+    beta+      = \ x_aYE ->+          case x_aYE of { W# x#_a1v0 ->+          W#+            (plusWord#+               (plusWord# (plusWord# x#_a1v0 0x0101010101010101##) 0x01010101##)+               0x0202##)+          }++Notice that the word literals are in hexadecimals and that they have+been padded with zeroes so that their lengths are 16, 8, and 4, respectively.++-}++-- | Apply 'parens' to 'Doc' if boolean is true.+maybeParens :: Bool -> Doc -> Doc+maybeParens False = id+maybeParens True = parens++-- ---------------------------------------------------------------------------+-- Structural operations on GDocs++-- | Perform some simplification of a built up @GDoc@.+reduceDoc :: Doc -> RDoc+reduceDoc (Beside p g q) = p `seq` g `seq` (beside p g $! reduceDoc q)+reduceDoc (Above  p g q) = p `seq` g `seq` (above  p g $! reduceDoc q)+reduceDoc p              = p++-- | List version of '<>'.+hcat :: [Doc] -> Doc+hcat = reduceAB . foldr (beside_' False) empty++-- | List version of '<+>'.+hsep :: [Doc] -> Doc+hsep = reduceAB . foldr (beside_' True)  empty++-- | List version of '$$'.+vcat :: [Doc] -> Doc+vcat = reduceAB . foldr (above_' False) empty++-- | Nest (or indent) a document by a given number of positions+-- (which may also be negative).  'nest' satisfies the laws:+--+-- * @'nest' 0 x = x@+--+-- * @'nest' k ('nest' k' x) = 'nest' (k+k') x@+--+-- * @'nest' k (x '<>' y) = 'nest' k z '<>' 'nest' k y@+--+-- * @'nest' k (x '$$' y) = 'nest' k x '$$' 'nest' k y@+--+-- * @'nest' k 'empty' = 'empty'@+--+-- * @x '<>' 'nest' k y = x '<>' y@, if @x@ non-empty+--+-- The side condition on the last law is needed because+-- 'empty' is a left identity for '<>'.+nest :: Int -> Doc -> Doc+nest k p = mkNest k (reduceDoc p)++-- | @hang d1 n d2 = sep [d1, nest n d2]@+hang :: Doc -> Int -> Doc -> Doc+hang d1 n d2 = sep [d1, nest n d2]++-- | Apply 'hang' to the arguments if the first 'Doc' is not empty.+hangNotEmpty :: Doc -> Int -> Doc -> Doc+hangNotEmpty d1 n d2 = if isEmpty d1+                       then d2+                       else hang d1 n d2++-- | @punctuate p [d1, ... dn] = [d1 \<> p, d2 \<> p, ... dn-1 \<> p, dn]@+punctuate :: Doc -> [Doc] -> [Doc]+punctuate _ []     = []+punctuate p (x:xs) = go x xs+                   where go y []     = [y]+                         go y (z:zs) = (y <> p) : go z zs++-- mkNest checks for Nest's invariant that it doesn't have an Empty inside it+mkNest :: Int -> Doc -> Doc+mkNest k _ | k `seq` False = undefined+mkNest k (Nest k1 p)       = mkNest (k + k1) p+mkNest _ NoDoc             = NoDoc+mkNest _ Empty             = Empty+mkNest 0 p                 = p+mkNest k p                 = nest_ k p++-- mkUnion checks for an empty document+mkUnion :: Doc -> Doc -> Doc+mkUnion Empty _ = Empty+mkUnion p q     = p `union_` q++beside_' :: Bool -> Doc -> Doc -> Doc+beside_' _ p Empty = p+beside_' g p q     = Beside p g q++above_' :: Bool -> Doc -> Doc -> Doc+above_' _ p Empty = p+above_' g p q     = Above p g q++reduceAB :: Doc -> Doc+reduceAB (Above  Empty _ q) = q+reduceAB (Beside Empty _ q) = q+reduceAB doc                = doc++nilAbove_ :: RDoc -> RDoc+nilAbove_ = NilAbove++-- Arg of a TextBeside is always an RDoc+textBeside_ :: TextDetails -> Int -> RDoc -> RDoc+textBeside_ = TextBeside++nest_ :: Int -> RDoc -> RDoc+nest_ = Nest++union_ :: RDoc -> RDoc -> RDoc+union_ = Union+++-- ---------------------------------------------------------------------------+-- Vertical composition @$$@++-- | Above, except that if the last line of the first argument stops+-- at least one position before the first line of the second begins,+-- these two lines are overlapped.  For example:+--+-- >    text "hi" $$ nest 5 (text "there")+--+-- lays out as+--+-- >    hi   there+--+-- rather than+--+-- >    hi+-- >         there+--+-- '$$' is associative, with identity 'empty', and also satisfies+--+-- * @(x '$$' y) '<>' z = x '$$' (y '<>' z)@, if @y@ non-empty.+--+($$) :: Doc -> Doc -> Doc+p $$  q = above_ p False q++-- | Above, with no overlapping.+-- '$+$' is associative, with identity 'empty'.+($+$) :: Doc -> Doc -> Doc+p $+$ q = above_ p True q++above_ :: Doc -> Bool -> Doc -> Doc+above_ p _ Empty = p+above_ Empty _ q = q+above_ p g q     = Above p g q++above :: Doc -> Bool -> RDoc -> RDoc+above (Above p g1 q1)  g2 q2 = above p g1 (above q1 g2 q2)+above p@(Beside{})     g  q  = aboveNest (reduceDoc p) g 0 (reduceDoc q)+above p g q                  = aboveNest p             g 0 (reduceDoc q)++-- Specification: aboveNest p g k q = p $g$ (nest k q)+aboveNest :: RDoc -> Bool -> Int -> RDoc -> RDoc+aboveNest _                   _ k _ | k `seq` False = undefined+aboveNest NoDoc               _ _ _ = NoDoc+aboveNest (p1 `Union` p2)     g k q = aboveNest p1 g k q `union_`+                                      aboveNest p2 g k q++aboveNest Empty               _ k q = mkNest k q+aboveNest (Nest k1 p)         g k q = nest_ k1 (aboveNest p g (k - k1) q)+                                  -- p can't be Empty, so no need for mkNest++aboveNest (NilAbove p)        g k q = nilAbove_ (aboveNest p g k q)+aboveNest (TextBeside s sl p) g k q = textBeside_ s sl rest+                                    where+                                      !k1  = k - sl+                                      rest = case p of+                                                Empty -> nilAboveNest g k1 q+                                                _     -> aboveNest  p g k1 q+aboveNest (Above {})          _ _ _ = error "aboveNest Above"+aboveNest (Beside {})         _ _ _ = error "aboveNest Beside"++-- Specification: text s <> nilaboveNest g k q+--              = text s <> (text "" $g$ nest k q)+nilAboveNest :: Bool -> Int -> RDoc -> RDoc+nilAboveNest _ k _           | k `seq` False = undefined+nilAboveNest _ _ Empty       = Empty+                               -- Here's why the "text s <>" is in the spec!+nilAboveNest g k (Nest k1 q) = nilAboveNest g (k + k1) q+nilAboveNest g k q           | not g && k > 0      -- No newline if no overlap+                             = textBeside_ (RStr k ' ') k q+                             | otherwise           -- Put them really above+                             = nilAbove_ (mkNest k q)+++-- ---------------------------------------------------------------------------+-- Horizontal composition @<>@++-- We intentionally avoid Data.Monoid.(<>) here due to interactions of+-- Data.Monoid.(<>) and (<+>).  See+-- http://www.haskell.org/pipermail/libraries/2011-November/017066.html++-- | Beside.+-- '<>' is associative, with identity 'empty'.+(<>) :: Doc -> Doc -> Doc+p <>  q = beside_ p False q++-- | Beside, separated by space, unless one of the arguments is 'empty'.+-- '<+>' is associative, with identity 'empty'.+(<+>) :: Doc -> Doc -> Doc+p <+> q = beside_ p True  q++beside_ :: Doc -> Bool -> Doc -> Doc+beside_ p _ Empty = p+beside_ Empty _ q = q+beside_ p g q     = Beside p g q++-- Specification: beside g p q = p <g> q+beside :: Doc -> Bool -> RDoc -> RDoc+beside NoDoc               _ _   = NoDoc+beside (p1 `Union` p2)     g q   = beside p1 g q `union_` beside p2 g q+beside Empty               _ q   = q+beside (Nest k p)          g q   = nest_ k $! beside p g q+beside p@(Beside p1 g1 q1) g2 q2+         | g1 == g2              = beside p1 g1 $! beside q1 g2 q2+         | otherwise             = beside (reduceDoc p) g2 q2+beside p@(Above{})         g q   = let !d = reduceDoc p in beside d g q+beside (NilAbove p)        g q   = nilAbove_ $! beside p g q+beside (TextBeside s sl p) g q   = textBeside_ s sl rest+                               where+                                  rest = case p of+                                           Empty -> nilBeside g q+                                           _     -> beside p g q++-- Specification: text "" <> nilBeside g p+--              = text "" <g> p+nilBeside :: Bool -> RDoc -> RDoc+nilBeside _ Empty         = Empty -- Hence the text "" in the spec+nilBeside g (Nest _ p)    = nilBeside g p+nilBeside g p | g         = textBeside_ spaceText 1 p+              | otherwise = p+++-- ---------------------------------------------------------------------------+-- Separate, @sep@++-- Specification: sep ps  = oneLiner (hsep ps)+--                         `union`+--                          vcat ps++-- | Either 'hsep' or 'vcat'.+sep  :: [Doc] -> Doc+sep = sepX True   -- Separate with spaces++-- | Either 'hcat' or 'vcat'.+cat :: [Doc] -> Doc+cat = sepX False  -- Don't++sepX :: Bool -> [Doc] -> Doc+sepX _ []     = empty+sepX x (p:ps) = sep1 x (reduceDoc p) 0 ps+++-- Specification: sep1 g k ys = sep (x : map (nest k) ys)+--                            = oneLiner (x <g> nest k (hsep ys))+--                              `union` x $$ nest k (vcat ys)+sep1 :: Bool -> RDoc -> Int -> [Doc] -> RDoc+sep1 _ _                   k _  | k `seq` False = undefined+sep1 _ NoDoc               _ _  = NoDoc+sep1 g (p `Union` q)       k ys = sep1 g p k ys `union_`+                                  aboveNest q False k (reduceDoc (vcat ys))++sep1 g Empty               k ys = mkNest k (sepX g ys)+sep1 g (Nest n p)          k ys = nest_ n (sep1 g p (k - n) ys)++sep1 _ (NilAbove p)        k ys = nilAbove_+                                  (aboveNest p False k (reduceDoc (vcat ys)))+sep1 g (TextBeside s sl p) k ys = textBeside_ s sl (sepNB g p (k - sl) ys)+sep1 _ (Above {})          _ _  = error "sep1 Above"+sep1 _ (Beside {})         _ _  = error "sep1 Beside"++-- Specification: sepNB p k ys = sep1 (text "" <> p) k ys+-- Called when we have already found some text in the first item+-- We have to eat up nests+sepNB :: Bool -> Doc -> Int -> [Doc] -> Doc+sepNB g (Nest _ p) k ys+  = sepNB g p k ys -- Never triggered, because of invariant (2)+sepNB g Empty k ys+  = oneLiner (nilBeside g (reduceDoc rest)) `mkUnion`+    -- XXX: TODO: PRETTY: Used to use True here (but GHC used False...)+    nilAboveNest False k (reduceDoc (vcat ys))+  where+    rest | g         = hsep ys+         | otherwise = hcat ys+sepNB g p k ys+  = sep1 g p k ys+++-- ---------------------------------------------------------------------------+-- @fill@++-- | \"Paragraph fill\" version of 'cat'.+fcat :: [Doc] -> Doc+fcat = fill False++-- | \"Paragraph fill\" version of 'sep'.+fsep :: [Doc] -> Doc+fsep = fill True++-- Specification:+--+-- fill g docs = fillIndent 0 docs+--+-- fillIndent k [] = []+-- fillIndent k [p] = p+-- fillIndent k (p1:p2:ps) =+--    oneLiner p1 <g> fillIndent (k + length p1 + g ? 1 : 0)+--                               (remove_nests (oneLiner p2) : ps)+--     `Union`+--    (p1 $*$ nest (-k) (fillIndent 0 ps))+--+-- $*$ is defined for layouts (not Docs) as+-- layout1 $*$ layout2 | hasMoreThanOneLine layout1 = layout1 $$ layout2+--                     | otherwise                  = layout1 $+$ layout2++fill :: Bool -> [Doc] -> RDoc+fill _ []     = empty+fill g (p:ps) = fill1 g (reduceDoc p) 0 ps++fill1 :: Bool -> RDoc -> Int -> [Doc] -> Doc+fill1 _ _                   k _  | k `seq` False = undefined+fill1 _ NoDoc               _ _  = NoDoc+fill1 g (p `Union` q)       k ys = fill1 g p k ys `union_`+                                   aboveNest q False k (fill g ys)+fill1 g Empty               k ys = mkNest k (fill g ys)+fill1 g (Nest n p)          k ys = nest_ n (fill1 g p (k - n) ys)+fill1 g (NilAbove p)        k ys = nilAbove_ (aboveNest p False k (fill g ys))+fill1 g (TextBeside s sl p) k ys = textBeside_ s sl (fillNB g p (k - sl) ys)+fill1 _ (Above {})          _ _  = error "fill1 Above"+fill1 _ (Beside {})         _ _  = error "fill1 Beside"++fillNB :: Bool -> Doc -> Int -> [Doc] -> Doc+fillNB _ _           k _  | k `seq` False = undefined+fillNB g (Nest _ p)  k ys   = fillNB g p k ys+                              -- Never triggered, because of invariant (2)+fillNB _ Empty _ []         = Empty+fillNB g Empty k (Empty:ys) = fillNB g Empty k ys+fillNB g Empty k (y:ys)     = fillNBE g k y ys+fillNB g p k ys             = fill1 g p k ys+++fillNBE :: Bool -> Int -> Doc -> [Doc] -> Doc+fillNBE g k y ys+  = nilBeside g (fill1 g ((elideNest . oneLiner . reduceDoc) y) k' ys)+    -- XXX: TODO: PRETTY: Used to use True here (but GHC used False...)+    `mkUnion` nilAboveNest False k (fill g (y:ys))+  where k' = if g then k - 1 else k++elideNest :: Doc -> Doc+elideNest (Nest _ d) = d+elideNest d          = d++-- ---------------------------------------------------------------------------+-- Selecting the best layout++best :: Int   -- Line length+     -> Int   -- Ribbon length+     -> RDoc+     -> RDoc  -- No unions in here!+best w0 r = get w0+  where+    get :: Int          -- (Remaining) width of line+        -> Doc -> Doc+    get w _ | w == 0 && False = undefined+    get _ Empty               = Empty+    get _ NoDoc               = NoDoc+    get w (NilAbove p)        = nilAbove_ (get w p)+    get w (TextBeside s sl p) = textBeside_ s sl (get1 w sl p)+    get w (Nest k p)          = nest_ k (get (w - k) p)+    get w (p `Union` q)       = nicest w r (get w p) (get w q)+    get _ (Above {})          = error "best get Above"+    get _ (Beside {})         = error "best get Beside"++    get1 :: Int         -- (Remaining) width of line+         -> Int         -- Amount of first line already eaten up+         -> Doc         -- This is an argument to TextBeside => eat Nests+         -> Doc         -- No unions in here!++    get1 w _ _ | w == 0 && False  = undefined+    get1 _ _  Empty               = Empty+    get1 _ _  NoDoc               = NoDoc+    get1 w sl (NilAbove p)        = nilAbove_ (get (w - sl) p)+    get1 w sl (TextBeside t tl p) = textBeside_ t tl (get1 w (sl + tl) p)+    get1 w sl (Nest _ p)          = get1 w sl p+    get1 w sl (p `Union` q)       = nicest1 w r sl (get1 w sl p)+                                                   (get1 w sl q)+    get1 _ _  (Above {})          = error "best get1 Above"+    get1 _ _  (Beside {})         = error "best get1 Beside"++nicest :: Int -> Int -> Doc -> Doc -> Doc+nicest !w !r = nicest1 w r 0++nicest1 :: Int -> Int -> Int -> Doc -> Doc -> Doc+nicest1 !w !r !sl p q | fits ((w `min` r) - sl) p = p+                      | otherwise                 = q++fits :: Int  -- Space available+     -> Doc+     -> Bool -- True if *first line* of Doc fits in space available+fits n _ | n < 0           = False+fits _ NoDoc               = False+fits _ Empty               = True+fits _ (NilAbove _)        = True+fits n (TextBeside _ sl p) = fits (n - sl) p+fits _ (Above {})          = error "fits Above"+fits _ (Beside {})         = error "fits Beside"+fits _ (Union {})          = error "fits Union"+fits _ (Nest {})           = error "fits Nest"++-- | @first@ returns its first argument if it is non-empty, otherwise its second.+first :: Doc -> Doc -> Doc+first p q | nonEmptySet p = p -- unused, because (get OneLineMode) is unused+          | otherwise     = q++nonEmptySet :: Doc -> Bool+nonEmptySet NoDoc              = False+nonEmptySet (_ `Union` _)      = True+nonEmptySet Empty              = True+nonEmptySet (NilAbove _)       = True+nonEmptySet (TextBeside _ _ p) = nonEmptySet p+nonEmptySet (Nest _ p)         = nonEmptySet p+nonEmptySet (Above {})         = error "nonEmptySet Above"+nonEmptySet (Beside {})        = error "nonEmptySet Beside"++-- @oneLiner@ returns the one-line members of the given set of @GDoc@s.+oneLiner :: Doc -> Doc+oneLiner NoDoc               = NoDoc+oneLiner Empty               = Empty+oneLiner (NilAbove _)        = NoDoc+oneLiner (TextBeside s sl p) = textBeside_ s sl (oneLiner p)+oneLiner (Nest k p)          = nest_ k (oneLiner p)+oneLiner (p `Union` _)       = oneLiner p+oneLiner (Above {})          = error "oneLiner Above"+oneLiner (Beside {})         = error "oneLiner Beside"+++-- ---------------------------------------------------------------------------+-- Rendering++-- | A rendering style.+data Style+  = Style { mode           :: Mode  -- ^ The rendering mode+          , lineLength     :: Int   -- ^ Length of line, in chars+          , ribbonsPerLine :: Float -- ^ Ratio of line length to ribbon length+          }++-- | The default style (@mode=PageMode, lineLength=100, ribbonsPerLine=1.5@).+style :: Style+style = Style { lineLength = 100, ribbonsPerLine = 1.5, mode = PageMode }++-- | Rendering mode.+data Mode = PageMode     -- ^ Normal+          | ZigZagMode   -- ^ With zig-zag cuts+          | LeftMode     -- ^ No indentation, infinitely long lines+          | OneLineMode  -- ^ All on one line++-- | Render the @Doc@ to a String using the given @Style@.+renderStyle :: Style -> Doc -> String+renderStyle s = fullRender (mode s) (lineLength s) (ribbonsPerLine s)+                txtPrinter ""++-- | Default TextDetails printer+txtPrinter :: TextDetails -> String -> String+txtPrinter (Chr c)    s  = c:s+txtPrinter (Str s1)   s2 = s1 ++ s2+txtPrinter (PStr s1)  s2 = unpackFS s1 ++ s2+txtPrinter (ZStr s1)  s2 = zString s1 ++ s2+txtPrinter (LStr s1)  s2 = unpackPtrString s1 ++ s2+txtPrinter (RStr n c) s2 = replicate n c ++ s2++-- | The general rendering interface.+fullRender :: Mode                     -- ^ Rendering mode+           -> Int                      -- ^ Line length+           -> Float                    -- ^ Ribbons per line+           -> (TextDetails -> a -> a)  -- ^ What to do with text+           -> a                        -- ^ What to do at the end+           -> Doc                      -- ^ The document+           -> a                        -- ^ Result+fullRender OneLineMode _ _ txt end doc+  = easyDisplay spaceText (\_ y -> y) txt end (reduceDoc doc)+fullRender LeftMode    _ _ txt end doc+  = easyDisplay nlText first txt end (reduceDoc doc)++fullRender m lineLen ribbons txt rest doc+  = display m lineLen ribbonLen txt rest doc'+  where+    doc' = best bestLineLen ribbonLen (reduceDoc doc)++    bestLineLen, ribbonLen :: Int+    ribbonLen   = round (fromIntegral lineLen / ribbons)+    bestLineLen = case m of+                      ZigZagMode -> maxBound+                      _          -> lineLen++easyDisplay :: TextDetails+             -> (Doc -> Doc -> Doc)+             -> (TextDetails -> a -> a)+             -> a+             -> Doc+             -> a+easyDisplay nlSpaceText choose txt end+  = lay+  where+    lay NoDoc              = error "easyDisplay: NoDoc"+    lay (Union p q)        = lay (choose p q)+    lay (Nest _ p)         = lay p+    lay Empty              = end+    lay (NilAbove p)       = nlSpaceText `txt` lay p+    lay (TextBeside s _ p) = s `txt` lay p+    lay (Above {})         = error "easyDisplay Above"+    lay (Beside {})        = error "easyDisplay Beside"++display :: Mode -> Int -> Int -> (TextDetails -> a -> a) -> a -> Doc -> a+display m !page_width !ribbon_width txt end doc+  = case page_width - ribbon_width of { gap_width ->+    case gap_width `quot` 2 of { shift ->+    let+        lay k _            | k `seq` False = undefined+        lay k (Nest k1 p)  = lay (k + k1) p+        lay _ Empty        = end+        lay k (NilAbove p) = nlText `txt` lay k p+        lay k (TextBeside s sl p)+            = case m of+                    ZigZagMode |  k >= gap_width+                               -> nlText `txt` (+                                  Str (replicate shift '/') `txt` (+                                  nlText `txt`+                                  lay1 (k - shift) s sl p ))++                               |  k < 0+                               -> nlText `txt` (+                                  Str (replicate shift '\\') `txt` (+                                  nlText `txt`+                                  lay1 (k + shift) s sl p ))++                    _ -> lay1 k s sl p+        lay _ (Above {})   = error "display lay Above"+        lay _ (Beside {})  = error "display lay Beside"+        lay _ NoDoc        = error "display lay NoDoc"+        lay _ (Union {})   = error "display lay Union"++        lay1 !k s !sl p    = let !r = k + sl+                             in indent k (s `txt` lay2 r p)++        lay2 k _ | k `seq` False   = undefined+        lay2 k (NilAbove p)        = nlText `txt` lay k p+        lay2 k (TextBeside s sl p) = s `txt` lay2 (k + sl) p+        lay2 k (Nest _ p)          = lay2 k p+        lay2 _ Empty               = end+        lay2 _ (Above {})          = error "display lay2 Above"+        lay2 _ (Beside {})         = error "display lay2 Beside"+        lay2 _ NoDoc               = error "display lay2 NoDoc"+        lay2 _ (Union {})          = error "display lay2 Union"++        indent !n r                = RStr n ' ' `txt` r+    in+    lay 0 doc+    }}++printDoc :: Mode -> Int -> Handle -> Doc -> IO ()+-- printDoc adds a newline to the end+printDoc mode cols hdl doc = printDoc_ mode cols hdl (doc $$ text "")++printDoc_ :: Mode -> Int -> Handle -> Doc -> IO ()+-- printDoc_ does not add a newline at the end, so that+-- successive calls can output stuff on the same line+-- Rather like putStr vs putStrLn+printDoc_ LeftMode _ hdl doc+  = do { printLeftRender hdl doc; hFlush hdl }+printDoc_ mode pprCols hdl doc+  = do { fullRender mode pprCols 1.5 put done doc ;+         hFlush hdl }+  where+    put (Chr c)    next = hPutChar hdl c >> next+    put (Str s)    next = hPutStr  hdl s >> next+    put (PStr s)   next = hPutStr  hdl (unpackFS s) >> next+                          -- NB. not hPutFS, we want this to go through+                          -- the I/O library's encoding layer. (#3398)+    put (ZStr s)   next = hPutFZS  hdl s >> next+    put (LStr s)   next = hPutPtrString hdl s >> next+    put (RStr n c) next = hPutStr hdl (replicate n c) >> next++    done = return () -- hPutChar hdl '\n'++  -- some versions of hPutBuf will barf if the length is zero+hPutPtrString :: Handle -> PtrString -> IO ()+hPutPtrString _handle (PtrString _ 0) = return ()+hPutPtrString handle  (PtrString a l) = hPutBuf handle a l++-- Printing output in LeftMode is performance critical: it's used when+-- dumping C and assembly output, so we allow ourselves a few dirty+-- hacks:+--+-- (1) we specialise fullRender for LeftMode with IO output.+--+-- (2) we add a layer of buffering on top of Handles.  Handles+--     don't perform well with lots of hPutChars, which is mostly+--     what we're doing here, because Handles have to be thread-safe+--     and async exception-safe.  We only have a single thread and don't+--     care about exceptions, so we add a layer of fast buffering+--     over the Handle interface.++printLeftRender :: Handle -> Doc -> IO ()+printLeftRender hdl doc = do+  b <- newBufHandle hdl+  bufLeftRender b doc+  bFlush b++bufLeftRender :: BufHandle -> Doc -> IO ()+bufLeftRender b doc = layLeft b (reduceDoc doc)++layLeft :: BufHandle -> Doc -> IO ()+layLeft b _ | b `seq` False  = undefined -- make it strict in b+layLeft _ NoDoc              = error "layLeft: NoDoc"+layLeft b (Union p q)        = layLeft b $! first p q+layLeft b (Nest _ p)         = layLeft b $! p+layLeft b Empty              = bPutChar b '\n'+layLeft b (NilAbove p)       = p `seq` (bPutChar b '\n' >> layLeft b p)+layLeft b (TextBeside s _ p) = s `seq` (put b s >> layLeft b p)+ where+    put b _ | b `seq` False = undefined+    put b (Chr c)    = bPutChar b c+    put b (Str s)    = bPutStr  b s+    put b (PStr s)   = bPutFS   b s+    put b (ZStr s)   = bPutFZS  b s+    put b (LStr s)   = bPutPtrString b s+    put b (RStr n c) = bPutReplicate b n c+layLeft _ _                  = panic "layLeft: Unhandled case"++-- Define error=panic, for easier comparison with libraries/pretty.+error :: String -> a+error = panic
+ compiler/GHC/Utils/Ppr/Colour.hs view
@@ -0,0 +1,101 @@+module GHC.Utils.Ppr.Colour where+import GHC.Prelude++import Data.Maybe (fromMaybe)+import GHC.Utils.Misc (OverridingBool(..), split)+import Data.Semigroup as Semi++-- | A colour\/style for use with 'coloured'.+newtype PprColour = PprColour { renderColour :: String }++instance Semi.Semigroup PprColour where+  PprColour s1 <> PprColour s2 = PprColour (s1 <> s2)++-- | Allow colours to be combined (e.g. bold + red);+--   In case of conflict, right side takes precedence.+instance Monoid PprColour where+  mempty = PprColour mempty+  mappend = (<>)++renderColourAfresh :: PprColour -> String+renderColourAfresh c = renderColour (colReset `mappend` c)++colCustom :: String -> PprColour+colCustom "" = mempty+colCustom s  = PprColour ("\27[" ++ s ++ "m")++colReset :: PprColour+colReset = colCustom "0"++colBold :: PprColour+colBold = colCustom ";1"++colBlackFg :: PprColour+colBlackFg = colCustom "30"++colRedFg :: PprColour+colRedFg = colCustom "31"++colGreenFg :: PprColour+colGreenFg = colCustom "32"++colYellowFg :: PprColour+colYellowFg = colCustom "33"++colBlueFg :: PprColour+colBlueFg = colCustom "34"++colMagentaFg :: PprColour+colMagentaFg = colCustom "35"++colCyanFg :: PprColour+colCyanFg = colCustom "36"++colWhiteFg :: PprColour+colWhiteFg = colCustom "37"++data Scheme =+  Scheme+  { sHeader  :: PprColour+  , sMessage :: PprColour+  , sWarning :: PprColour+  , sError   :: PprColour+  , sFatal   :: PprColour+  , sMargin  :: PprColour+  }++defaultScheme :: Scheme+defaultScheme =+  Scheme+  { sHeader  = mempty+  , sMessage = colBold+  , sWarning = colBold `mappend` colMagentaFg+  , sError   = colBold `mappend` colRedFg+  , sFatal   = colBold `mappend` colRedFg+  , sMargin  = colBold `mappend` colBlueFg+  }++-- | Parse the colour scheme from a string (presumably from the @GHC_COLORS@+-- environment variable).+parseScheme :: String -> (OverridingBool, Scheme) -> (OverridingBool, Scheme)+parseScheme "always" (_, cs) = (Always, cs)+parseScheme "auto"   (_, cs) = (Auto,   cs)+parseScheme "never"  (_, cs) = (Never,  cs)+parseScheme input    (b, cs) =+  ( b+  , Scheme+    { sHeader  = fromMaybe (sHeader cs)  (lookup "header" table)+    , sMessage = fromMaybe (sMessage cs) (lookup "message" table)+    , sWarning = fromMaybe (sWarning cs) (lookup "warning" table)+    , sError   = fromMaybe (sError cs)   (lookup "error"   table)+    , sFatal   = fromMaybe (sFatal cs)   (lookup "fatal"   table)+    , sMargin  = fromMaybe (sMargin cs)  (lookup "margin"  table)+    }+  )+  where+    table = do+      w <- split ':' input+      let (k, v') = break (== '=') w+      case v' of+        '=' : v -> return (k, colCustom v)+        _ -> []
compiler/HsVersions.h view
@@ -15,25 +15,25 @@ #define GLOBAL_VAR(name,value,ty)  \ {-# NOINLINE name #-};             \ name :: IORef (ty);                \-name = Util.global (value);+name = GHC.Utils.Misc.global (value);  #define GLOBAL_VAR_M(name,value,ty) \ {-# NOINLINE name #-};              \ name :: IORef (ty);                 \-name = Util.globalM (value);+name = GHC.Utils.Misc.globalM (value);   #define SHARED_GLOBAL_VAR(name,accessor,saccessor,value,ty) \ {-# NOINLINE name #-};                                      \ name :: IORef (ty);                                         \-name = Util.sharedGlobal (value) (accessor);                \+name = GHC.Utils.Misc.sharedGlobal (value) (accessor);      \ foreign import ccall unsafe saccessor                       \   accessor :: Ptr (IORef a) -> IO (Ptr (IORef a));  #define SHARED_GLOBAL_VAR_M(name,accessor,saccessor,value,ty)  \ {-# NOINLINE name #-};                                         \ name :: IORef (ty);                                            \-name = Util.sharedGlobalM (value) (accessor);                  \+name = GHC.Utils.Misc.sharedGlobalM (value) (accessor);        \ foreign import ccall unsafe saccessor                          \   accessor :: Ptr (IORef a) -> IO (Ptr (IORef a));
− compiler/iface/BinFingerprint.hs 
@@ -1,49 +0,0 @@-{-# LANGUAGE CPP #-}---- | Computing fingerprints of values serializeable with GHC's "Binary" module.-module BinFingerprint-  ( -- * Computing fingerprints-    fingerprintBinMem-  , computeFingerprint-  , putNameLiterally-  ) where--#include "HsVersions.h"--import GhcPrelude--import Fingerprint-import Binary-import GHC.Types.Name-import PlainPanic-import Util--fingerprintBinMem :: BinHandle -> IO Fingerprint-fingerprintBinMem bh = withBinBuffer bh f-  where-    f bs =-        -- we need to take care that we force the result here-        -- lest a reference to the ByteString may leak out of-        -- withBinBuffer.-        let fp = fingerprintByteString bs-        in fp `seq` return fp--computeFingerprint :: (Binary a)-                   => (BinHandle -> Name -> IO ())-                   -> a-                   -> IO Fingerprint-computeFingerprint put_nonbinding_name a = do-    bh <- fmap set_user_data $ openBinMem (3*1024) -- just less than a block-    put_ bh a-    fp <- fingerprintBinMem bh-    return fp-  where-    set_user_data bh =-      setUserData bh $ newWriteState put_nonbinding_name putNameLiterally putFS---- | Used when we want to fingerprint a structure without depending on the--- fingerprints of external Names that it refers to.-putNameLiterally :: BinHandle -> Name -> IO ()-putNameLiterally bh name = ASSERT( isExternalName name ) do-    put_ bh $! nameModule name-    put_ bh $! nameOccName name
− compiler/main/CliOption.hs 
@@ -1,27 +0,0 @@-module CliOption-  ( Option (..)-  , showOpt-  ) where--import GhcPrelude---- -------------------------------------------------------------------------------- Command-line options---- | When invoking external tools as part of the compilation pipeline, we--- pass these a sequence of options on the command-line. Rather than--- just using a list of Strings, we use a type that allows us to distinguish--- between filepaths and 'other stuff'. The reason for this is that--- this type gives us a handle on transforming filenames, and filenames only,--- to whatever format they're expected to be on a particular platform.-data Option- = FileOption -- an entry that _contains_ filename(s) / filepaths.-              String  -- a non-filepath prefix that shouldn't be-                      -- transformed (e.g., "/out=")-              String  -- the filepath/filename portion- | Option     String- deriving ( Eq )--showOpt :: Option -> String-showOpt (FileOption pre f) = pre ++ f-showOpt (Option s)  = s
− compiler/main/Constants.hs 
@@ -1,50 +0,0 @@-{--(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[Constants]{Info about this compilation}--}--module Constants (module Constants) where--import GhcPrelude--import Config--hiVersion :: Integer-hiVersion = read (cProjectVersionInt ++ cProjectPatchLevel) :: Integer---- All pretty arbitrary:--mAX_TUPLE_SIZE :: Int-mAX_TUPLE_SIZE = 62 -- Should really match the number-                    -- of decls in Data.Tuple--mAX_CTUPLE_SIZE :: Int   -- Constraint tuples-mAX_CTUPLE_SIZE = 62     -- Should match the number of decls in GHC.Classes--mAX_SUM_SIZE :: Int-mAX_SUM_SIZE = 62---- | Default maximum depth for both class instance search and type family--- reduction. See also #5395.-mAX_REDUCTION_DEPTH :: Int-mAX_REDUCTION_DEPTH = 200---- | Default maximum constraint-solver iterations--- Typically there should be very few-mAX_SOLVER_ITERATIONS :: Int-mAX_SOLVER_ITERATIONS = 4--wORD64_SIZE :: Int-wORD64_SIZE = 8---- Size of float in bytes.-fLOAT_SIZE :: Int-fLOAT_SIZE = 4---- Size of double in bytes.-dOUBLE_SIZE :: Int-dOUBLE_SIZE = 8--tARGET_MAX_CHAR :: Int-tARGET_MAX_CHAR = 0x10ffff
− compiler/main/ErrUtils.hs 
@@ -1,975 +0,0 @@-{--(c) The AQUA Project, Glasgow University, 1994-1998--\section[ErrsUtils]{Utilities for error reporting}--}--{-# LANGUAGE CPP #-}-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE RecordWildCards #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE LambdaCase #-}--module ErrUtils (-        -- * Basic types-        Validity(..), andValid, allValid, isValid, getInvalids, orValid,-        Severity(..),--        -- * Messages-        ErrMsg, errMsgDoc, errMsgSeverity, errMsgReason,-        ErrDoc, errDoc, errDocImportant, errDocContext, errDocSupplementary,-        WarnMsg, MsgDoc,-        Messages, ErrorMessages, WarningMessages,-        unionMessages,-        errMsgSpan, errMsgContext,-        errorsFound, isEmptyMessages,-        isWarnMsgFatal,-        warningsToMessages,--        -- ** Formatting-        pprMessageBag, pprErrMsgBagWithLoc,-        pprLocErrMsg, printBagOfErrors,-        formatErrDoc,--        -- ** Construction-        emptyMessages, mkLocMessage, mkLocMessageAnn, makeIntoWarning,-        mkErrMsg, mkPlainErrMsg, mkErrDoc, mkLongErrMsg, mkWarnMsg,-        mkPlainWarnMsg,-        mkLongWarnMsg,--        -- * Utilities-        doIfSet, doIfSet_dyn,-        getCaretDiagnostic,--        -- * Dump files-        dumpIfSet, dumpIfSet_dyn, dumpIfSet_dyn_printer,-        dumpOptionsFromFlag, DumpOptions (..),-        DumpFormat (..), DumpAction, dumpAction, defaultDumpAction,-        TraceAction, traceAction, defaultTraceAction,-        touchDumpFile,--        -- * Issuing messages during compilation-        putMsg, printInfoForUser, printOutputForUser,-        logInfo, logOutput,-        errorMsg, warningMsg,-        fatalErrorMsg, fatalErrorMsg'',-        compilationProgressMsg,-        showPass,-        withTiming, withTimingSilent, withTimingD, withTimingSilentD,-        debugTraceMsg,-        ghcExit,-        prettyPrintGhcErrors,-        traceCmd-    ) where--#include "HsVersions.h"--import GhcPrelude--import Bag-import Exception-import Outputable-import Panic-import qualified PprColour as Col-import GHC.Types.SrcLoc as SrcLoc-import GHC.Driver.Session-import FastString (unpackFS)-import StringBuffer (atLine, hGetStringBuffer, len, lexemeToString)-import Json--import System.Directory-import System.Exit      ( ExitCode(..), exitWith )-import System.FilePath  ( takeDirectory, (</>) )-import Data.List-import qualified Data.Set as Set-import Data.IORef-import Data.Maybe       ( fromMaybe )-import Data.Function-import Data.Time-import Debug.Trace-import Control.Monad-import Control.Monad.IO.Class-import System.IO-import System.IO.Error  ( catchIOError )-import GHC.Conc         ( getAllocationCounter )-import System.CPUTime----------------------------type MsgDoc  = SDoc----------------------------data Validity-  = IsValid            -- ^ Everything is fine-  | NotValid MsgDoc    -- ^ A problem, and some indication of why--isValid :: Validity -> Bool-isValid IsValid       = True-isValid (NotValid {}) = False--andValid :: Validity -> Validity -> Validity-andValid IsValid v = v-andValid v _       = v---- | If they aren't all valid, return the first-allValid :: [Validity] -> Validity-allValid []       = IsValid-allValid (v : vs) = v `andValid` allValid vs--getInvalids :: [Validity] -> [MsgDoc]-getInvalids vs = [d | NotValid d <- vs]--orValid :: Validity -> Validity -> Validity-orValid IsValid _ = IsValid-orValid _       v = v---- -------------------------------------------------------------------------------- Basic error messages: just render a message with a source location.--type Messages        = (WarningMessages, ErrorMessages)-type WarningMessages = Bag WarnMsg-type ErrorMessages   = Bag ErrMsg--unionMessages :: Messages -> Messages -> Messages-unionMessages (warns1, errs1) (warns2, errs2) =-  (warns1 `unionBags` warns2, errs1 `unionBags` errs2)--data ErrMsg = ErrMsg {-        errMsgSpan        :: SrcSpan,-        errMsgContext     :: PrintUnqualified,-        errMsgDoc         :: ErrDoc,-        -- | This has the same text as errDocImportant . errMsgDoc.-        errMsgShortString :: String,-        errMsgSeverity    :: Severity,-        errMsgReason      :: WarnReason-        }-        -- The SrcSpan is used for sorting errors into line-number order----- | Categorise error msgs by their importance.  This is so each section can--- be rendered visually distinct.  See Note [Error report] for where these come--- from.-data ErrDoc = ErrDoc {-        -- | Primary error msg.-        errDocImportant     :: [MsgDoc],-        -- | Context e.g. \"In the second argument of ...\".-        errDocContext       :: [MsgDoc],-        -- | Supplementary information, e.g. \"Relevant bindings include ...\".-        errDocSupplementary :: [MsgDoc]-        }--errDoc :: [MsgDoc] -> [MsgDoc] -> [MsgDoc] -> ErrDoc-errDoc = ErrDoc--type WarnMsg = ErrMsg--data Severity-  = SevOutput-  | SevFatal-  | SevInteractive--  | SevDump-    -- ^ Log message intended for compiler developers-    -- No file/line/column stuff--  | SevInfo-    -- ^ Log messages intended for end users.-    -- No file/line/column stuff.--  | SevWarning-  | SevError-    -- ^ SevWarning and SevError are used for warnings and errors-    --   o The message has a file/line/column heading,-    --     plus "warning:" or "error:",-    --     added by mkLocMessags-    --   o Output is intended for end users-  deriving Show---instance ToJson Severity where-  json s = JSString (show s)---instance Show ErrMsg where-    show em = errMsgShortString em--pprMessageBag :: Bag MsgDoc -> SDoc-pprMessageBag msgs = vcat (punctuate blankLine (bagToList msgs))---- | Make an unannotated error message with location info.-mkLocMessage :: Severity -> SrcSpan -> MsgDoc -> MsgDoc-mkLocMessage = mkLocMessageAnn Nothing---- | Make a possibly annotated error message with location info.-mkLocMessageAnn-  :: Maybe String                       -- ^ optional annotation-  -> Severity                           -- ^ severity-  -> SrcSpan                            -- ^ location-  -> MsgDoc                             -- ^ message-  -> MsgDoc-  -- Always print the location, even if it is unhelpful.  Error messages-  -- 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-    = sdocOption sdocColScheme $ \col_scheme ->-      let locn' = sdocOption sdocErrorSpans $ \case-                     True  -> ppr locn-                     False -> ppr (srcSpanStart locn)--          sevColour = getSeverityColour severity col_scheme--          -- Add optional information-          optAnn = case ann of-            Nothing -> text ""-            Just i  -> text " [" <> coloured sevColour (text i) <> text "]"--          -- Add prefixes, like    Foo.hs:34: warning:-          --                           <the warning message>-          header = locn' <> colon <+>-                   coloured sevColour sevText <> optAnn--      in coloured (Col.sMessage col_scheme)-                  (hang (coloured (Col.sHeader col_scheme) header) 4-                        msg)--  where-    sevText =-      case severity of-        SevWarning -> text "warning:"-        SevError   -> text "error:"-        SevFatal   -> text "fatal:"-        _          -> empty--getSeverityColour :: Severity -> Col.Scheme -> Col.PprColour-getSeverityColour SevWarning = Col.sWarning-getSeverityColour SevError   = Col.sError-getSeverityColour SevFatal   = Col.sFatal-getSeverityColour _          = const mempty--getCaretDiagnostic :: Severity -> SrcSpan -> IO MsgDoc-getCaretDiagnostic _ (UnhelpfulSpan _) = pure empty-getCaretDiagnostic severity (RealSrcSpan span _) = do-  caretDiagnostic <$> getSrcLine (srcSpanFile span) row--  where-    getSrcLine fn i =-      getLine i (unpackFS fn)-        `catchIOError` \_ ->-          pure Nothing--    getLine i fn = do-      -- StringBuffer has advantages over readFile:-      -- (a) no lazy IO, otherwise IO exceptions may occur in pure code-      -- (b) always UTF-8, rather than some system-dependent encoding-      --     (Haskell source code must be UTF-8 anyway)-      content <- hGetStringBuffer fn-      case atLine i content of-        Just at_line -> pure $-          case lines (fix <$> lexemeToString at_line (len at_line)) of-            srcLine : _ -> Just srcLine-            _           -> Nothing-        _ -> pure Nothing--    -- allow user to visibly see that their code is incorrectly encoded-    -- (StringBuffer.nextChar uses \0 to represent undecodable characters)-    fix '\0' = '\xfffd'-    fix c    = c--    row = srcSpanStartLine span-    rowStr = show row-    multiline = row /= srcSpanEndLine span--    caretDiagnostic Nothing = empty-    caretDiagnostic (Just srcLineWithNewline) =-      sdocOption sdocColScheme$ \col_scheme ->-      let sevColour = getSeverityColour severity col_scheme-          marginColour = Col.sMargin col_scheme-      in-      coloured marginColour (text marginSpace) <>-      text ("\n") <>-      coloured marginColour (text marginRow) <>-      text (" " ++ srcLinePre) <>-      coloured sevColour (text srcLineSpan) <>-      text (srcLinePost ++ "\n") <>-      coloured marginColour (text marginSpace) <>-      coloured sevColour (text (" " ++ caretLine))--      where--        -- expand tabs in a device-independent manner #13664-        expandTabs tabWidth i s =-          case s of-            ""        -> ""-            '\t' : cs -> replicate effectiveWidth ' ' ++-                         expandTabs tabWidth (i + effectiveWidth) cs-            c    : cs -> c : expandTabs tabWidth (i + 1) cs-          where effectiveWidth = tabWidth - i `mod` tabWidth--        srcLine = filter (/= '\n') (expandTabs 8 0 srcLineWithNewline)--        start = srcSpanStartCol span - 1-        end | multiline = length srcLine-            | otherwise = srcSpanEndCol span - 1-        width = max 1 (end - start)--        marginWidth = length rowStr-        marginSpace = replicate marginWidth ' ' ++ " |"-        marginRow   = rowStr ++ " |"--        (srcLinePre,  srcLineRest) = splitAt start srcLine-        (srcLineSpan, srcLinePost) = splitAt width srcLineRest--        caretEllipsis | multiline = "..."-                      | otherwise = ""-        caretLine = replicate start ' ' ++ replicate width '^' ++ caretEllipsis--makeIntoWarning :: WarnReason -> ErrMsg -> ErrMsg-makeIntoWarning reason err = err-    { errMsgSeverity = SevWarning-    , errMsgReason = reason }---- -------------------------------------------------------------------------------- Collecting up messages for later ordering and printing.--mk_err_msg :: DynFlags -> Severity -> SrcSpan -> PrintUnqualified -> ErrDoc -> ErrMsg-mk_err_msg dflags sev locn print_unqual doc- = ErrMsg { errMsgSpan = locn-          , errMsgContext = print_unqual-          , errMsgDoc = doc-          , errMsgShortString = showSDoc dflags (vcat (errDocImportant doc))-          , errMsgSeverity = sev-          , errMsgReason = NoReason }--mkErrDoc :: DynFlags -> SrcSpan -> PrintUnqualified -> ErrDoc -> ErrMsg-mkErrDoc dflags = mk_err_msg dflags SevError--mkLongErrMsg, mkLongWarnMsg   :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> MsgDoc -> ErrMsg--- ^ A long (multi-line) error message-mkErrMsg, mkWarnMsg           :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc            -> ErrMsg--- ^ A short (one-line) error message-mkPlainErrMsg, mkPlainWarnMsg :: DynFlags -> SrcSpan ->                     MsgDoc            -> ErrMsg--- ^ Variant that doesn't care about qualified/unqualified names--mkLongErrMsg   dflags locn unqual msg extra = mk_err_msg dflags SevError   locn unqual        (ErrDoc [msg] [] [extra])-mkErrMsg       dflags locn unqual msg       = mk_err_msg dflags SevError   locn unqual        (ErrDoc [msg] [] [])-mkPlainErrMsg  dflags locn        msg       = mk_err_msg dflags SevError   locn alwaysQualify (ErrDoc [msg] [] [])-mkLongWarnMsg  dflags locn unqual msg extra = mk_err_msg dflags SevWarning locn unqual        (ErrDoc [msg] [] [extra])-mkWarnMsg      dflags locn unqual msg       = mk_err_msg dflags SevWarning locn unqual        (ErrDoc [msg] [] [])-mkPlainWarnMsg dflags locn        msg       = mk_err_msg dflags SevWarning locn alwaysQualify (ErrDoc [msg] [] [])-------------------emptyMessages :: Messages-emptyMessages = (emptyBag, emptyBag)--isEmptyMessages :: Messages -> Bool-isEmptyMessages (warns, errs) = isEmptyBag warns && isEmptyBag errs--errorsFound :: DynFlags -> Messages -> Bool-errorsFound _dflags (_warns, errs) = not (isEmptyBag errs)--warningsToMessages :: DynFlags -> WarningMessages -> Messages-warningsToMessages dflags =-  partitionBagWith $ \warn ->-    case isWarnMsgFatal dflags warn of-      Nothing -> Left warn-      Just err_reason ->-        Right warn{ errMsgSeverity = SevError-                  , errMsgReason = ErrReason err_reason }--printBagOfErrors :: DynFlags -> Bag ErrMsg -> IO ()-printBagOfErrors dflags bag_of_errors-  = sequence_ [ let style = mkErrStyle dflags unqual-                    ctx   = initSDocContext dflags style-                in putLogMsg dflags reason sev s style (formatErrDoc ctx doc)-              | ErrMsg { errMsgSpan      = s,-                         errMsgDoc       = doc,-                         errMsgSeverity  = sev,-                         errMsgReason    = reason,-                         errMsgContext   = unqual } <- sortMsgBag (Just dflags)-                                                                  bag_of_errors ]--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 ctx))-        [important, context, supplementary]-    starred = (bullet<+>) . vcat--pprErrMsgBagWithLoc :: Bag ErrMsg -> [SDoc]-pprErrMsgBagWithLoc bag = [ pprLocErrMsg item | item <- sortMsgBag Nothing bag ]--pprLocErrMsg :: ErrMsg -> SDoc-pprLocErrMsg (ErrMsg { errMsgSpan      = s-                     , errMsgDoc       = doc-                     , errMsgSeverity  = sev-                     , errMsgContext   = unqual })-  = sdocWithContext $ \ctx ->-    withErrStyle unqual $ mkLocMessage sev s (formatErrDoc ctx doc)--sortMsgBag :: Maybe DynFlags -> Bag ErrMsg -> [ErrMsg]-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--ghcExit :: DynFlags -> Int -> IO ()-ghcExit dflags val-  | val == 0  = exitWith ExitSuccess-  | otherwise = do errorMsg dflags (text "\nCompilation had errors\n\n")-                   exitWith (ExitFailure val)--doIfSet :: Bool -> IO () -> IO ()-doIfSet flag action | flag      = action-                    | otherwise = return ()--doIfSet_dyn :: DynFlags -> GeneralFlag -> IO () -> IO()-doIfSet_dyn dflags flag action | gopt flag dflags = action-                               | otherwise        = return ()---- -------------------------------------------------------------------------------- Dumping--dumpIfSet :: DynFlags -> Bool -> String -> SDoc -> IO ()-dumpIfSet dflags flag hdr doc-  | not flag   = return ()-  | otherwise  = putLogMsg  dflags-                            NoReason-                            SevDump-                            noSrcSpan-                            (defaultDumpStyle dflags)-                            (mkDumpDoc hdr doc)---- | a wrapper around 'dumpAction'.--- First check whether the dump flag is set--- Do nothing if it is unset-dumpIfSet_dyn :: DynFlags -> DumpFlag -> String -> DumpFormat -> SDoc -> IO ()-dumpIfSet_dyn = dumpIfSet_dyn_printer alwaysQualify---- | a wrapper around 'dumpAction'.--- First check whether the dump flag is set--- Do nothing if it is unset------ Unlike 'dumpIfSet_dyn', has a printer argument-dumpIfSet_dyn_printer :: PrintUnqualified -> DynFlags -> DumpFlag -> String-                         -> DumpFormat -> SDoc -> IO ()-dumpIfSet_dyn_printer printer dflags flag hdr fmt doc-  = when (dopt flag dflags) $ do-      let sty = mkDumpStyle dflags printer-      dumpAction dflags sty (dumpOptionsFromFlag flag) hdr fmt doc--mkDumpDoc :: String -> SDoc -> SDoc-mkDumpDoc hdr doc-   = vcat [blankLine,-           line <+> text hdr <+> line,-           doc,-           blankLine]-     where-        line = text (replicate 20 '=')----- | Ensure that a dump file is created even if it stays empty-touchDumpFile :: DynFlags -> DumpOptions -> IO ()-touchDumpFile dflags dumpOpt = withDumpFileHandle dflags dumpOpt (const (return ()))---- | Run an action with the handle of a 'DumpFlag' if we are outputting to a--- file, otherwise 'Nothing'.-withDumpFileHandle :: DynFlags -> DumpOptions -> (Maybe Handle -> IO ()) -> IO ()-withDumpFileHandle dflags dumpOpt action = do-    let mFile = chooseDumpFile dflags dumpOpt-    case mFile of-      Just fileName -> do-        let gdref = generatedDumps dflags-        gd <- readIORef gdref-        let append = Set.member fileName gd-            mode = if append then AppendMode else WriteMode-        unless append $-            writeIORef gdref (Set.insert fileName gd)-        createDirectoryIfMissing True (takeDirectory fileName)-        withFile fileName mode $ \handle -> do-            -- We do not want the dump file to be affected by-            -- environment variables, but instead to always use-            -- UTF8. See:-            -- https://gitlab.haskell.org/ghc/ghc/issues/10762-            hSetEncoding handle utf8--            action (Just handle)-      Nothing -> action Nothing----- | Write out a dump.--- If --dump-to-file is set then this goes to a file.--- otherwise emit to stdout.------ When @hdr@ is empty, we print in a more compact format (no separators and--- blank lines)-dumpSDocWithStyle :: PprStyle -> DynFlags -> DumpOptions -> String -> SDoc -> IO ()-dumpSDocWithStyle sty dflags dumpOpt hdr doc =-    withDumpFileHandle dflags dumpOpt writeDump-  where-    -- write dump to file-    writeDump (Just handle) = do-        doc' <- if null hdr-                then return doc-                else do t <- getCurrentTime-                        let timeStamp = if (gopt Opt_SuppressTimestamps dflags)-                                          then empty-                                          else text (show t)-                        let d = timeStamp-                                $$ blankLine-                                $$ doc-                        return $ mkDumpDoc hdr d-        defaultLogActionHPrintDoc dflags handle doc' sty--    -- write the dump to stdout-    writeDump Nothing = do-        let (doc', severity)-              | null hdr  = (doc, SevOutput)-              | otherwise = (mkDumpDoc hdr doc, SevDump)-        putLogMsg dflags NoReason severity noSrcSpan sty doc'----- | Choose where to put a dump file based on DynFlags----chooseDumpFile :: DynFlags -> DumpOptions -> Maybe FilePath-chooseDumpFile dflags dumpOpt--        | gopt Opt_DumpToFile dflags || dumpForcedToFile dumpOpt-        , Just prefix <- getPrefix-        = Just $ setDir (prefix ++ dumpSuffix dumpOpt)--        | otherwise-        = Nothing--        where getPrefix-                 -- dump file location is being forced-                 --      by the --ddump-file-prefix flag.-               | Just prefix <- dumpPrefixForce dflags-                  = Just prefix-                 -- 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.-               | otherwise-                  = Nothing-              setDir f = case dumpDir dflags of-                         Just d  -> d </> f-                         Nothing ->       f---- | Dump options------ Dumps are printed on stdout by default except when the `dumpForcedToFile`--- field is set to True.------ When `dumpForcedToFile` is True or when `-ddump-to-file` is set, dumps are--- written into a file whose suffix is given in the `dumpSuffix` field.----data DumpOptions = DumpOptions-   { dumpForcedToFile :: Bool   -- ^ Must be dumped into a file, even if-                                --   -ddump-to-file isn't set-   , dumpSuffix       :: String -- ^ Filename suffix used when dumped into-                                --   a file-   }---- | Create dump options from a 'DumpFlag'-dumpOptionsFromFlag :: DumpFlag -> DumpOptions-dumpOptionsFromFlag Opt_D_th_dec_file =-   DumpOptions                        -- -dth-dec-file dumps expansions of TH-      { dumpForcedToFile = True       -- splices into MODULE.th.hs even when-      , dumpSuffix       = "th.hs"    -- -ddump-to-file isn't set-      }-dumpOptionsFromFlag flag =-   DumpOptions-      { dumpForcedToFile = False-      , dumpSuffix       = suffix -- build a suffix from the flag name-      }                           -- e.g. -ddump-asm => ".dump-asm"-   where-      str  = show flag-      suff = case stripPrefix "Opt_D_" str of-             Just x  -> x-             Nothing -> panic ("Bad flag name: " ++ str)-      suffix = map (\c -> if c == '_' then '-' else c) suff----- -------------------------------------------------------------------------------- Outputting messages from the compiler---- We want all messages to go through one place, so that we can--- redirect them if necessary.  For example, when GHC is used as a--- library we might want to catch all messages that GHC tries to--- output and do something else with them.--ifVerbose :: DynFlags -> Int -> IO () -> IO ()-ifVerbose dflags val act-  | verbosity dflags >= val = act-  | otherwise               = return ()--errorMsg :: DynFlags -> MsgDoc -> IO ()-errorMsg dflags msg-   = putLogMsg dflags NoReason SevError noSrcSpan (defaultErrStyle dflags) msg--warningMsg :: DynFlags -> MsgDoc -> IO ()-warningMsg dflags msg-   = putLogMsg dflags NoReason SevWarning noSrcSpan (defaultErrStyle dflags) msg--fatalErrorMsg :: DynFlags -> MsgDoc -> IO ()-fatalErrorMsg dflags msg =-    putLogMsg dflags NoReason SevFatal noSrcSpan (defaultErrStyle dflags) msg--fatalErrorMsg'' :: FatalMessager -> String -> IO ()-fatalErrorMsg'' fm msg = fm msg--compilationProgressMsg :: DynFlags -> String -> IO ()-compilationProgressMsg dflags msg = do-    traceEventIO $ "GHC progress: " ++ msg-    ifVerbose dflags 1 $-        logOutput dflags (defaultUserStyle dflags) (text msg)--showPass :: DynFlags -> String -> IO ()-showPass dflags what-  = ifVerbose dflags 2 $-    logInfo dflags (defaultUserStyle dflags) (text "***" <+> text what <> colon)--data PrintTimings = PrintTimings | DontPrintTimings-  deriving (Eq, Show)---- | Time a compilation phase.------ When timings are enabled (e.g. with the @-v2@ flag), the allocations--- and CPU time used by the phase will be reported to stderr. Consider--- a typical usage:--- @withTiming getDynFlags (text "simplify") force PrintTimings pass@.--- When timings are enabled the following costs are included in the--- produced accounting,------  - The cost of executing @pass@ to a result @r@ in WHNF---  - The cost of evaluating @force r@ to WHNF (e.g. @()@)------ The choice of the @force@ function depends upon the amount of forcing--- desired; the goal here is to ensure that the cost of evaluating the result--- is, to the greatest extent possible, included in the accounting provided by--- 'withTiming'. Often the pass already sufficiently forces its result during--- construction; in this case @const ()@ is a reasonable choice.--- In other cases, it is necessary to evaluate the result to normal form, in--- which case something like @Control.DeepSeq.rnf@ is appropriate.------ To avoid adversely affecting compiler performance when timings are not--- requested, the result is only forced when timings are enabled.------ See Note [withTiming] for more.-withTiming :: MonadIO m-           => DynFlags     -- ^ DynFlags-           -> SDoc         -- ^ The name of the phase-           -> (a -> ())    -- ^ A function to force the result-                           -- (often either @const ()@ or 'rnf')-           -> m a          -- ^ The body of the phase to be timed-           -> m a-withTiming dflags what force action =-  withTiming' dflags what force PrintTimings action---- | Like withTiming but get DynFlags from the Monad.-withTimingD :: (MonadIO m, HasDynFlags m)-           => SDoc         -- ^ The name of the phase-           -> (a -> ())    -- ^ A function to force the result-                           -- (often either @const ()@ or 'rnf')-           -> m a          -- ^ The body of the phase to be timed-           -> m a-withTimingD what force action = do-  dflags <- getDynFlags-  withTiming' dflags what force PrintTimings action----- | Same as 'withTiming', but doesn't print timings in the---   console (when given @-vN@, @N >= 2@ or @-ddump-timings@).------   See Note [withTiming] for more.-withTimingSilent-  :: MonadIO m-  => DynFlags   -- ^ DynFlags-  -> SDoc       -- ^ The name of the phase-  -> (a -> ())  -- ^ A function to force the result-                -- (often either @const ()@ or 'rnf')-  -> m a        -- ^ The body of the phase to be timed-  -> m a-withTimingSilent dflags what force action =-  withTiming' dflags what force DontPrintTimings action---- | Same as 'withTiming', but doesn't print timings in the---   console (when given @-vN@, @N >= 2@ or @-ddump-timings@)---   and gets the DynFlags from the given Monad.------   See Note [withTiming] for more.-withTimingSilentD-  :: (MonadIO m, HasDynFlags m)-  => SDoc       -- ^ The name of the phase-  -> (a -> ())  -- ^ A function to force the result-                -- (often either @const ()@ or 'rnf')-  -> m a        -- ^ The body of the phase to be timed-  -> m a-withTimingSilentD what force action = do-  dflags <- getDynFlags-  withTiming' dflags what force DontPrintTimings action---- | Worker for 'withTiming' and 'withTimingSilent'.-withTiming' :: MonadIO m-            => DynFlags   -- ^ A means of getting a 'DynFlags' (often-                            -- 'getDynFlags' will work here)-            -> SDoc         -- ^ The name of the phase-            -> (a -> ())    -- ^ A function to force the result-                            -- (often either @const ()@ or 'rnf')-            -> PrintTimings -- ^ Whether to print the timings-            -> m a          -- ^ The body of the phase to be timed-            -> m a-withTiming' dflags what force_result prtimings action-  = do if verbosity dflags >= 2 || dopt Opt_D_dump_timings dflags-          then do whenPrintTimings $-                    logInfo dflags (defaultUserStyle dflags) $-                      text "***" <+> what <> colon-                  eventBegins dflags what-                  alloc0 <- liftIO getAllocationCounter-                  start <- liftIO getCPUTime-                  !r <- action-                  () <- pure $ force_result r-                  eventEnds dflags what-                  end <- liftIO getCPUTime-                  alloc1 <- liftIO getAllocationCounter-                  -- recall that allocation counter counts down-                  let alloc = alloc0 - alloc1-                      time = realToFrac (end - start) * 1e-9--                  when (verbosity dflags >= 2 && prtimings == PrintTimings)-                      $ liftIO $ logInfo dflags (defaultUserStyle dflags)-                          (text "!!!" <+> what <> colon <+> text "finished in"-                           <+> doublePrec 2 time-                           <+> text "milliseconds"-                           <> comma-                           <+> text "allocated"-                           <+> doublePrec 3 (realToFrac alloc / 1024 / 1024)-                           <+> text "megabytes")--                  whenPrintTimings $-                      dumpIfSet_dyn dflags Opt_D_dump_timings "" FormatText-                          $ text $ showSDocOneLine dflags-                          $ hsep [ what <> colon-                                 , text "alloc=" <> ppr alloc-                                 , text "time=" <> doublePrec 3 time-                                 ]-                  pure r-           else action--    where whenPrintTimings = liftIO . when (prtimings == PrintTimings)-          eventBegins dflags w = do-            whenPrintTimings $ traceMarkerIO (eventBeginsDoc dflags w)-            liftIO $ traceEventIO (eventBeginsDoc dflags w)-          eventEnds dflags w = do-            whenPrintTimings $ traceMarkerIO (eventEndsDoc dflags w)-            liftIO $ traceEventIO (eventEndsDoc dflags w)--          eventBeginsDoc dflags w = showSDocOneLine dflags $ text "GHC:started:" <+> w-          eventEndsDoc dflags w = showSDocOneLine dflags $ text "GHC:finished:" <+> w--debugTraceMsg :: DynFlags -> Int -> MsgDoc -> IO ()-debugTraceMsg dflags val msg = ifVerbose dflags val $-                               logInfo dflags (defaultDumpStyle dflags) msg-putMsg :: DynFlags -> MsgDoc -> IO ()-putMsg dflags msg = logInfo dflags (defaultUserStyle dflags) msg--printInfoForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()-printInfoForUser dflags print_unqual msg-  = logInfo dflags (mkUserStyle dflags print_unqual AllTheWay) msg--printOutputForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()-printOutputForUser dflags print_unqual msg-  = logOutput dflags (mkUserStyle dflags print_unqual AllTheWay) msg--logInfo :: DynFlags -> PprStyle -> MsgDoc -> IO ()-logInfo dflags sty msg-  = putLogMsg dflags NoReason SevInfo noSrcSpan sty msg--logOutput :: DynFlags -> PprStyle -> MsgDoc -> IO ()--- ^ Like 'logInfo' but with 'SevOutput' rather then 'SevInfo'-logOutput dflags sty msg-  = putLogMsg dflags NoReason SevOutput noSrcSpan sty msg--prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a-prettyPrintGhcErrors dflags-    = ghandle $ \e -> case e of-                      PprPanic str doc ->-                          pprDebugAndThen dflags panic (text str) doc-                      PprSorry str doc ->-                          pprDebugAndThen dflags sorry (text str) doc-                      PprProgramError str doc ->-                          pprDebugAndThen dflags pgmError (text str) doc-                      _ ->-                          liftIO $ throwIO e---- | Checks if given 'WarnMsg' is a fatal warning.-isWarnMsgFatal :: DynFlags -> WarnMsg -> Maybe (Maybe WarningFlag)-isWarnMsgFatal dflags ErrMsg{errMsgReason = Reason wflag}-  = if wopt_fatal wflag dflags-      then Just (Just wflag)-      else Nothing-isWarnMsgFatal dflags _-  = if gopt Opt_WarnIsError dflags-      then Just Nothing-      else Nothing--traceCmd :: DynFlags -> String -> String -> IO a -> IO a--- trace the command (at two levels of verbosity)-traceCmd dflags phase_name cmd_line action- = do   { let verb = verbosity dflags-        ; showPass dflags phase_name-        ; debugTraceMsg dflags 3 (text cmd_line)-        ; case flushErr dflags of-              FlushErr io -> io--           -- And run it!-        ; action `catchIO` handle_exn verb-        }-  where-    handle_exn _verb exn = do { debugTraceMsg dflags 2 (char '\n')-                              ; debugTraceMsg dflags 2-                                (text "Failed:"-                                 <+> text cmd_line-                                 <+> text (show exn))-                              ; throwGhcExceptionIO (ProgramError (show exn))}--{- Note [withTiming]-~~~~~~~~~~~~~~~~~~~~--For reference:--  withTiming-    :: MonadIO-    => m DynFlags   -- how to get the DynFlags-    -> SDoc         -- label for the computation we're timing-    -> (a -> ())    -- how to evaluate the result-    -> PrintTimings -- whether to report the timings when passed-                    -- -v2 or -ddump-timings-    -> m a          -- computation we're timing-    -> m a--withTiming lets you run an action while:--(1) measuring the CPU time it took and reporting that on stderr-    (when PrintTimings is passed),-(2) emitting start/stop events to GHC's event log, with the label-    given as an argument.--Evaluation of the result---------------------------'withTiming' takes as an argument a function of type 'a -> ()', whose purpose is-to evaluate the result "sufficiently". A given pass might return an 'm a' for-some monad 'm' and result type 'a', but where the 'a' is complex enough-that evaluating it to WHNF barely scratches its surface and leaves many-complex and time-consuming computations unevaluated. Those would only be-forced by the next pass, and the time needed to evaluate them would be-mis-attributed to that next pass. A more appropriate function would be-one that deeply evaluates the result, so as to assign the time spent doing it-to the pass we're timing.--Note: as hinted at above, the time spent evaluating the application of the-forcing function to the result is included in the timings reported by-'withTiming'.--How we use it----------------We measure the time and allocations of various passes in GHC's pipeline by just-wrapping the whole pass with 'withTiming'. This also materializes by having-a label for each pass in the eventlog, where each pass is executed in one go,-during a continuous time window.--However, from STG onwards, the pipeline uses streams to emit groups of-STG/Cmm/etc declarations one at a time, and process them until we get to-assembly code generation. This means that the execution of those last few passes-is interleaved and that we cannot measure how long they take by just wrapping-the whole thing with 'withTiming'. Instead we wrap the processing of each-individual stream element, all along the codegen pipeline, using the appropriate-label for the pass to which this processing belongs. That generates a lot more-data but allows us to get fine-grained timings about all the passes and we can-easily compute totals with tools like ghc-events-analyze (see below).---Producing an eventlog for GHC--------------------------------To actually produce the eventlog, you need an eventlog-capable GHC build:--  With Hadrian:-  $ hadrian/build -j "stage1.ghc-bin.ghc.link.opts += -eventlog"--  With Make:-  $ make -j GhcStage2HcOpts+=-eventlog--You can then produce an eventlog when compiling say hello.hs by simply-doing:--  If GHC was built by Hadrian:-  $ _build/stage1/bin/ghc -ddump-timings hello.hs -o hello +RTS -l--  If GHC was built with Make:-  $ inplace/bin/ghc-stage2 -ddump-timing hello.hs -o hello +RTS -l--You could alternatively use -v<N> (with N >= 2) instead of -ddump-timings,-to ask GHC to report timings (on stderr and the eventlog).--This will write the eventlog to ./ghc.eventlog in both cases. You can then-visualize it or look at the totals for each label by using ghc-events-analyze,-threadscope or any other eventlog consumer. Illustrating with-ghc-events-analyze:--  $ ghc-events-analyze --timed --timed-txt --totals \-                       --start "GHC:started:" --stop "GHC:finished:" \-                       ghc.eventlog--This produces ghc.timed.txt (all event timestamps), ghc.timed.svg (visualisation-of the execution through the various labels) and ghc.totals.txt (total time-spent in each label).---}----- | Format of a dump------ Dump formats are loosely defined: dumps may contain various additional--- headers and annotations and they may be partial. 'DumpFormat' is mainly a hint--- (e.g. for syntax highlighters).-data DumpFormat-   = FormatHaskell   -- ^ Haskell-   | FormatCore      -- ^ Core-   | FormatSTG       -- ^ STG-   | FormatByteCode  -- ^ ByteCode-   | FormatCMM       -- ^ Cmm-   | FormatASM       -- ^ Assembly code-   | FormatC         -- ^ C code/header-   | FormatLLVM      -- ^ LLVM bytecode-   | FormatText      -- ^ Unstructured dump-   deriving (Show,Eq)--type DumpAction = DynFlags -> PprStyle -> DumpOptions -> String-                  -> DumpFormat -> SDoc -> IO ()--type TraceAction = forall a. DynFlags -> String -> SDoc -> a -> a---- | Default action for 'dumpAction' hook-defaultDumpAction :: DumpAction-defaultDumpAction dflags sty dumpOpt title _fmt doc = do-   dumpSDocWithStyle sty dflags dumpOpt title doc---- | Default action for 'traceAction' hook-defaultTraceAction :: TraceAction-defaultTraceAction dflags title doc = pprTraceWithFlags dflags title doc---- | Helper for `dump_action`-dumpAction :: DumpAction-dumpAction dflags = dump_action dflags dflags---- | Helper for `trace_action`-traceAction :: TraceAction-traceAction dflags = trace_action dflags dflags
− compiler/main/ErrUtils.hs-boot 
@@ -1,50 +0,0 @@-{-# LANGUAGE RankNTypes #-}--module ErrUtils where--import GhcPrelude-import Outputable (SDoc, PprStyle )-import GHC.Types.SrcLoc (SrcSpan)-import Json-import {-# SOURCE #-} GHC.Driver.Session ( DynFlags )--type DumpAction = DynFlags -> PprStyle -> DumpOptions -> String-                  -> DumpFormat -> SDoc -> IO ()--type TraceAction = forall a. DynFlags -> String -> SDoc -> a -> a--data DumpOptions = DumpOptions-   { dumpForcedToFile :: Bool-   , dumpSuffix       :: String-   }--data DumpFormat-  = FormatHaskell-  | FormatCore-  | FormatSTG-  | FormatByteCode-  | FormatCMM-  | FormatASM-  | FormatC-  | FormatLLVM-  | FormatText--data Severity-  = SevOutput-  | SevFatal-  | SevInteractive-  | SevDump-  | SevInfo-  | SevWarning-  | SevError---type MsgDoc = SDoc--mkLocMessage :: Severity -> SrcSpan -> MsgDoc -> MsgDoc-mkLocMessageAnn :: Maybe String -> Severity -> SrcSpan -> MsgDoc -> MsgDoc-getCaretDiagnostic :: Severity -> SrcSpan -> IO MsgDoc-defaultDumpAction :: DumpAction-defaultTraceAction :: TraceAction--instance ToJson Severity
− compiler/main/FileCleanup.hs 
@@ -1,314 +0,0 @@-{-# LANGUAGE CPP #-}-module FileCleanup-  ( TempFileLifetime(..)-  , cleanTempDirs, cleanTempFiles, cleanCurrentModuleTempFiles-  , addFilesToClean, changeTempFilesLifetime-  , newTempName, newTempLibName, newTempDir-  , withSystemTempDirectory, withTempDirectory-  ) where--import GhcPrelude--import GHC.Driver.Session-import ErrUtils-import Outputable-import Util-import Exception-import GHC.Driver.Phases--import Control.Monad-import Data.List-import qualified Data.Set as Set-import qualified Data.Map as Map-import Data.IORef-import System.Directory-import System.FilePath-import System.IO.Error--#if !defined(mingw32_HOST_OS)-import qualified System.Posix.Internals-#endif---- | Used when a temp file is created. This determines which component Set of--- FilesToClean will get the temp file-data TempFileLifetime-  = TFL_CurrentModule-  -- ^ A file with lifetime TFL_CurrentModule will be cleaned up at the-  -- end of upweep_mod-  | TFL_GhcSession-  -- ^ A file with lifetime TFL_GhcSession will be cleaned up at the end of-  -- runGhc(T)-  deriving (Show)--cleanTempDirs :: DynFlags -> IO ()-cleanTempDirs dflags-   = unless (gopt Opt_KeepTmpFiles dflags)-   $ mask_-   $ do let ref = dirsToClean dflags-        ds <- atomicModifyIORef' ref $ \ds -> (Map.empty, ds)-        removeTmpDirs dflags (Map.elems ds)---- | Delete all files in @filesToClean dflags@.-cleanTempFiles :: DynFlags -> IO ()-cleanTempFiles dflags-   = unless (gopt Opt_KeepTmpFiles dflags)-   $ mask_-   $ do let ref = filesToClean dflags-        to_delete <- atomicModifyIORef' ref $-            \FilesToClean-                { ftcCurrentModule = cm_files-                , ftcGhcSession = gs_files-                } -> ( emptyFilesToClean-                     , Set.toList cm_files ++ Set.toList gs_files)-        removeTmpFiles dflags to_delete---- | Delete all files in @filesToClean dflags@. That have lifetime--- TFL_CurrentModule.--- If a file must be cleaned eventually, but must survive a--- cleanCurrentModuleTempFiles, ensure it has lifetime TFL_GhcSession.-cleanCurrentModuleTempFiles :: DynFlags -> IO ()-cleanCurrentModuleTempFiles dflags-   = unless (gopt Opt_KeepTmpFiles dflags)-   $ mask_-   $ do let ref = filesToClean dflags-        to_delete <- atomicModifyIORef' ref $-            \ftc@FilesToClean{ftcCurrentModule = cm_files} ->-                (ftc {ftcCurrentModule = Set.empty}, Set.toList cm_files)-        removeTmpFiles dflags to_delete---- | Ensure that new_files are cleaned on the next call of--- 'cleanTempFiles' or 'cleanCurrentModuleTempFiles', depending on lifetime.--- If any of new_files are already tracked, they will have their lifetime--- updated.-addFilesToClean :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()-addFilesToClean dflags lifetime new_files = modifyIORef' (filesToClean dflags) $-  \FilesToClean-    { ftcCurrentModule = cm_files-    , ftcGhcSession = gs_files-    } -> case lifetime of-      TFL_CurrentModule -> FilesToClean-        { ftcCurrentModule = cm_files `Set.union` new_files_set-        , ftcGhcSession = gs_files `Set.difference` new_files_set-        }-      TFL_GhcSession -> FilesToClean-        { ftcCurrentModule = cm_files `Set.difference` new_files_set-        , ftcGhcSession = gs_files `Set.union` new_files_set-        }-  where-    new_files_set = Set.fromList new_files---- | Update the lifetime of files already being tracked. If any files are--- not being tracked they will be discarded.-changeTempFilesLifetime :: DynFlags -> TempFileLifetime -> [FilePath] -> IO ()-changeTempFilesLifetime dflags lifetime files = do-  FilesToClean-    { ftcCurrentModule = cm_files-    , ftcGhcSession = gs_files-    } <- readIORef (filesToClean dflags)-  let old_set = case lifetime of-        TFL_CurrentModule -> gs_files-        TFL_GhcSession -> cm_files-      existing_files = [f | f <- files, f `Set.member` old_set]-  addFilesToClean dflags lifetime existing_files---- Return a unique numeric temp file suffix-newTempSuffix :: DynFlags -> IO Int-newTempSuffix dflags =-  atomicModifyIORef' (nextTempSuffix dflags) $ \n -> (n+1,n)---- Find a temporary name that doesn't already exist.-newTempName :: DynFlags -> TempFileLifetime -> Suffix -> IO FilePath-newTempName dflags lifetime extn-  = do d <- getTempDir dflags-       findTempName (d </> "ghc_") -- See Note [Deterministic base name]-  where-    findTempName :: FilePath -> IO FilePath-    findTempName prefix-      = do n <- newTempSuffix dflags-           let filename = prefix ++ show n <.> extn-           b <- doesFileExist filename-           if b then findTempName prefix-                else do -- clean it up later-                        addFilesToClean dflags lifetime [filename]-                        return filename--newTempDir :: DynFlags -> IO FilePath-newTempDir dflags-  = do d <- getTempDir dflags-       findTempDir (d </> "ghc_")-  where-    findTempDir :: FilePath -> IO FilePath-    findTempDir prefix-      = do n <- newTempSuffix dflags-           let filename = prefix ++ show n-           b <- doesDirectoryExist filename-           if b then findTempDir prefix-                else do createDirectory filename-                        -- see mkTempDir below; this is wrong: -> consIORef (dirsToClean dflags) filename-                        return filename--newTempLibName :: DynFlags -> TempFileLifetime -> Suffix-  -> IO (FilePath, FilePath, String)-newTempLibName dflags lifetime extn-  = do d <- getTempDir dflags-       findTempName d ("ghc_")-  where-    findTempName :: FilePath -> String -> IO (FilePath, FilePath, String)-    findTempName dir prefix-      = do n <- newTempSuffix dflags -- See Note [Deterministic base name]-           let libname = prefix ++ show n-               filename = dir </> "lib" ++ libname <.> extn-           b <- doesFileExist filename-           if b then findTempName dir prefix-                else do -- clean it up later-                        addFilesToClean dflags lifetime [filename]-                        return (filename, dir, libname)----- Return our temporary directory within tmp_dir, creating one if we--- don't have one yet.-getTempDir :: DynFlags -> IO FilePath-getTempDir dflags = do-    mapping <- readIORef dir_ref-    case Map.lookup tmp_dir mapping of-        Nothing -> do-            pid <- getProcessID-            let prefix = tmp_dir </> "ghc" ++ show pid ++ "_"-            mask_ $ mkTempDir prefix-        Just dir -> return dir-  where-    tmp_dir = tmpDir dflags-    dir_ref = dirsToClean dflags--    mkTempDir :: FilePath -> IO FilePath-    mkTempDir prefix = do-        n <- newTempSuffix dflags-        let our_dir = prefix ++ show n--        -- 1. Speculatively create our new directory.-        createDirectory our_dir--        -- 2. Update the dirsToClean mapping unless an entry already exists-        -- (i.e. unless another thread beat us to it).-        their_dir <- atomicModifyIORef' dir_ref $ \mapping ->-            case Map.lookup tmp_dir mapping of-                Just dir -> (mapping, Just dir)-                Nothing  -> (Map.insert tmp_dir our_dir mapping, Nothing)--        -- 3. If there was an existing entry, return it and delete the-        -- directory we created.  Otherwise return the directory we created.-        case their_dir of-            Nothing  -> do-                debugTraceMsg dflags 2 $-                    text "Created temporary directory:" <+> text our_dir-                return our_dir-            Just dir -> do-                removeDirectory our_dir-                return dir-      `catchIO` \e -> if isAlreadyExistsError e-                      then mkTempDir prefix else ioError e--{- Note [Deterministic base name]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--The filename of temporary files, especially the basename of C files, can end-up in the output in some form, e.g. as part of linker debug information. In the-interest of bit-wise exactly reproducible compilation (#4012), the basename of-the temporary file no longer contains random information (it used to contain-the process id).--This is ok, as the temporary directory used contains the pid (see getTempDir).--}-removeTmpDirs :: DynFlags -> [FilePath] -> IO ()-removeTmpDirs dflags ds-  = traceCmd dflags "Deleting temp dirs"-             ("Deleting: " ++ unwords ds)-             (mapM_ (removeWith dflags removeDirectory) ds)--removeTmpFiles :: DynFlags -> [FilePath] -> IO ()-removeTmpFiles dflags fs-  = warnNon $-    traceCmd dflags "Deleting temp files"-             ("Deleting: " ++ unwords deletees)-             (mapM_ (removeWith dflags removeFile) deletees)-  where-     -- Flat out refuse to delete files that are likely to be source input-     -- files (is there a worse bug than having a compiler delete your source-     -- files?)-     ---     -- Deleting source files is a sign of a bug elsewhere, so prominently flag-     -- the condition.-    warnNon act-     | null non_deletees = act-     | otherwise         = do-        putMsg dflags (text "WARNING - NOT deleting source files:"-                       <+> hsep (map text non_deletees))-        act--    (non_deletees, deletees) = partition isHaskellUserSrcFilename fs--removeWith :: DynFlags -> (FilePath -> IO ()) -> FilePath -> IO ()-removeWith dflags remover f = remover f `catchIO`-  (\e ->-   let msg = if isDoesNotExistError e-             then text "Warning: deleting non-existent" <+> text f-             else text "Warning: exception raised when deleting"-                                            <+> text f <> colon-               $$ text (show e)-   in debugTraceMsg dflags 2 msg-  )--#if defined(mingw32_HOST_OS)--- relies on Int == Int32 on Windows-foreign import ccall unsafe "_getpid" getProcessID :: IO Int-#else-getProcessID :: IO Int-getProcessID = System.Posix.Internals.c_getpid >>= return . fromIntegral-#endif---- The following three functions are from the `temporary` package.---- | Create and use a temporary directory in the system standard temporary--- directory.------ Behaves exactly the same as 'withTempDirectory', except that the parent--- temporary directory will be that returned by 'getTemporaryDirectory'.-withSystemTempDirectory :: String   -- ^ Directory name template. See 'openTempFile'.-                        -> (FilePath -> IO a) -- ^ Callback that can use the directory-                        -> IO a-withSystemTempDirectory template action =-  getTemporaryDirectory >>= \tmpDir -> withTempDirectory tmpDir template action----- | Create and use a temporary directory.------ Creates a new temporary directory inside the given directory, making use--- of the template. The temp directory is deleted after use. For example:------ > withTempDirectory "src" "sdist." $ \tmpDir -> do ...------ The @tmpDir@ will be a new subdirectory of the given directory, e.g.--- @src/sdist.342@.-withTempDirectory :: FilePath -- ^ Temp directory to create the directory in-                  -> String   -- ^ Directory name template. See 'openTempFile'.-                  -> (FilePath -> IO a) -- ^ Callback that can use the directory-                  -> IO a-withTempDirectory targetDir template =-  Exception.bracket-    (createTempDirectory targetDir template)-    (ignoringIOErrors . removeDirectoryRecursive)--ignoringIOErrors :: IO () -> IO ()-ignoringIOErrors ioe = ioe `catch` (\e -> const (return ()) (e :: IOError))---createTempDirectory :: FilePath -> String -> IO FilePath-createTempDirectory dir template = do-  pid <- getProcessID-  findTempName pid-  where findTempName x = do-            let path = dir </> template ++ show x-            createDirectory path-            return path-          `catchIO` \e -> if isAlreadyExistsError e-                          then findTempName (x+1) else ioError e
− compiler/main/FileSettings.hs 
@@ -1,16 +0,0 @@-module FileSettings-  ( FileSettings (..)-  ) where--import GhcPrelude---- | Paths to various files and directories used by GHC, including those that--- provide more settings.-data FileSettings = FileSettings-  { fileSettings_ghcUsagePath          :: FilePath       -- ditto-  , fileSettings_ghciUsagePath         :: FilePath       -- ditto-  , fileSettings_toolDir               :: Maybe FilePath -- ditto-  , fileSettings_topDir                :: FilePath       -- ditto-  , fileSettings_tmpDir                :: String      -- no trailing '/'-  , fileSettings_globalPackageDatabase :: FilePath-  }
− compiler/main/GhcNameVersion.hs 
@@ -1,11 +0,0 @@-module GhcNameVersion-  ( GhcNameVersion (..)-  ) where--import GhcPrelude---- | Settings for what GHC this is.-data GhcNameVersion = GhcNameVersion-  { ghcNameVersion_programName    :: String-  , ghcNameVersion_projectVersion :: String-  }
− compiler/main/HeaderInfo.hs 
@@ -1,357 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE ViewPatterns #-}-{-# LANGUAGE TypeFamilies #-}------------------------------------------------------------------------------------- | Parsing the top of a Haskell source file to get its module name,--- imports and options.------ (c) Simon Marlow 2005--- (c) Lemmih 2006-----------------------------------------------------------------------------------module HeaderInfo ( getImports-                  , mkPrelImports -- used by the renamer too-                  , getOptionsFromFile, getOptions-                  , optionsErrorMsgs,-                    checkProcessArgsResult ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.Platform-import GHC.Driver.Types-import Parser           ( parseHeader )-import Lexer-import FastString-import GHC.Hs-import GHC.Types.Module-import PrelNames-import StringBuffer-import GHC.Types.SrcLoc-import GHC.Driver.Session-import ErrUtils-import Util-import Outputable-import Maybes-import Bag              ( emptyBag, listToBag, unitBag )-import MonadUtils-import Exception-import GHC.Types.Basic-import qualified GHC.LanguageExtensions as LangExt--import Control.Monad-import System.IO-import System.IO.Unsafe-import Data.List------------------------------------------------------------------------------------ | Parse the imports of a source file.------ Throws a 'SourceError' if parsing fails.-getImports :: DynFlags-           -> StringBuffer -- ^ Parse this.-           -> FilePath     -- ^ Filename the buffer came from.  Used for-                           --   reporting parse error locations.-           -> FilePath     -- ^ The original source filename (used for locations-                           --   in the function result)-           -> IO (Either-               ErrorMessages-               ([(Maybe FastString, Located ModuleName)],-                [(Maybe FastString, Located ModuleName)],-                Located ModuleName))-              -- ^ The source imports and normal imports (with optional package-              -- names from -XPackageImports), and the module name.-getImports dflags buf filename source_filename = do-  let loc  = mkRealSrcLoc (mkFastString filename) 1 1-  case unP parseHeader (mkPState dflags buf loc) of-    PFailed pst ->-        -- assuming we're not logging warnings here as per below-      return $ Left $ getErrorMessages pst dflags-    POk pst rdr_module -> fmap Right $ do-      let _ms@(_warns, errs) = getMessages pst dflags-      -- don't log warnings: they'll be reported when we parse the file-      -- for real.  See #2500.-          ms = (emptyBag, errs)-      -- logWarnings warns-      if errorsFound dflags ms-        then throwIO $ mkSrcErr errs-        else-          let   hsmod = unLoc rdr_module-                mb_mod = hsmodName hsmod-                imps = hsmodImports hsmod-                main_loc = srcLocSpan (mkSrcLoc (mkFastString source_filename)-                                       1 1)-                mod = mb_mod `orElse` L main_loc mAIN_NAME-                (src_idecls, ord_idecls) = partition (ideclSource.unLoc) imps--               -- GHC.Prim doesn't exist physically, so don't go looking for it.-                ordinary_imps = filter ((/= moduleName gHC_PRIM) . unLoc-                                        . ideclName . unLoc)-                                       ord_idecls--                implicit_prelude = xopt LangExt.ImplicitPrelude dflags-                implicit_imports = mkPrelImports (unLoc mod) main_loc-                                                 implicit_prelude imps-                convImport (L _ i) = (fmap sl_fs (ideclPkgQual i), ideclName i)-              in-              return (map convImport src_idecls,-                      map convImport (implicit_imports ++ ordinary_imps),-                      mod)--mkPrelImports :: ModuleName-              -> SrcSpan    -- Attribute the "import Prelude" to this location-              -> Bool -> [LImportDecl GhcPs]-              -> [LImportDecl GhcPs]--- Construct the implicit declaration "import Prelude" (or not)------ NB: opt_NoImplicitPrelude is slightly different to import Prelude ();--- because the former doesn't even look at Prelude.hi for instance--- declarations, whereas the latter does.-mkPrelImports this_mod loc implicit_prelude import_decls-  | this_mod == pRELUDE_NAME-   || explicit_prelude_import-   || not implicit_prelude-  = []-  | otherwise = [preludeImportDecl]-  where-      explicit_prelude_import-       = notNull [ () | L _ (ImportDecl { ideclName = mod-                                        , ideclPkgQual = Nothing })-                          <- import_decls-                      , unLoc mod == pRELUDE_NAME ]--      preludeImportDecl :: LImportDecl GhcPs-      preludeImportDecl-        = L loc $ ImportDecl { ideclExt       = noExtField,-                               ideclSourceSrc = NoSourceText,-                               ideclName      = L loc pRELUDE_NAME,-                               ideclPkgQual   = Nothing,-                               ideclSource    = False,-                               ideclSafe      = False,  -- Not a safe import-                               ideclQualified = NotQualified,-                               ideclImplicit  = True,   -- Implicit!-                               ideclAs        = Nothing,-                               ideclHiding    = Nothing  }------------------------------------------------------------------- Get options------------------------------------------------------------------- | Parse OPTIONS and LANGUAGE pragmas of the source file.------ Throws a 'SourceError' if flag parsing fails (including unsupported flags.)-getOptionsFromFile :: DynFlags-                   -> FilePath            -- ^ Input file-                   -> IO [Located String] -- ^ Parsed options, if any.-getOptionsFromFile dflags filename-    = Exception.bracket-              (openBinaryFile filename ReadMode)-              (hClose)-              (\handle -> do-                  opts <- fmap (getOptions' dflags)-                               (lazyGetToks dflags' filename handle)-                  seqList opts $ return opts)-    where -- We don't need to get haddock doc tokens when we're just-          -- getting the options from pragmas, and lazily lexing them-          -- correctly is a little tricky: If there is "\n" or "\n-"-          -- left at the end of a buffer then the haddock doc may-          -- continue past the end of the buffer, despite the fact that-          -- we already have an apparently-complete token.-          -- We therefore just turn Opt_Haddock off when doing the lazy-          -- lex.-          dflags' = gopt_unset dflags Opt_Haddock--blockSize :: Int--- blockSize = 17 -- for testing :-)-blockSize = 1024--lazyGetToks :: DynFlags -> FilePath -> Handle -> IO [Located Token]-lazyGetToks dflags filename handle = do-  buf <- hGetStringBufferBlock handle blockSize-  unsafeInterleaveIO $ lazyLexBuf handle (pragState dflags buf loc) False blockSize- where-  loc  = mkRealSrcLoc (mkFastString filename) 1 1--  lazyLexBuf :: Handle -> PState -> Bool -> Int -> IO [Located Token]-  lazyLexBuf handle state eof size = do-    case unP (lexer False return) state of-      POk state' t -> do-        -- pprTrace "lazyLexBuf" (text (show (buffer state'))) (return ())-        if atEnd (buffer state') && not eof-           -- if this token reached the end of the buffer, and we haven't-           -- necessarily read up to the end of the file, then the token might-           -- be truncated, so read some more of the file and lex it again.-           then getMore handle state size-           else case unLoc t of-                  ITeof  -> return [t]-                  _other -> do rest <- lazyLexBuf handle state' eof size-                               return (t : rest)-      _ | not eof   -> getMore handle state size-        | otherwise -> return [L (mkSrcSpanPs (last_loc state)) ITeof]-                         -- parser assumes an ITeof sentinel at the end--  getMore :: Handle -> PState -> Int -> IO [Located Token]-  getMore handle state size = do-     -- pprTrace "getMore" (text (show (buffer state))) (return ())-     let new_size = size * 2-       -- double the buffer size each time we read a new block.  This-       -- counteracts the quadratic slowdown we otherwise get for very-       -- large module names (#5981)-     nextbuf <- hGetStringBufferBlock handle new_size-     if (len nextbuf == 0) then lazyLexBuf handle state True new_size else do-       newbuf <- appendStringBuffers (buffer state) nextbuf-       unsafeInterleaveIO $ lazyLexBuf handle state{buffer=newbuf} False new_size---getToks :: DynFlags -> FilePath -> StringBuffer -> [Located Token]-getToks dflags filename buf = lexAll (pragState dflags buf loc)- where-  loc  = mkRealSrcLoc (mkFastString filename) 1 1--  lexAll state = case unP (lexer False return) state of-                   POk _      t@(L _ ITeof) -> [t]-                   POk state' t -> t : lexAll state'-                   _ -> [L (mkSrcSpanPs (last_loc state)) ITeof]----- | Parse OPTIONS and LANGUAGE pragmas of the source file.------ Throws a 'SourceError' if flag parsing fails (including unsupported flags.)-getOptions :: DynFlags-           -> StringBuffer -- ^ Input Buffer-           -> FilePath     -- ^ Source filename.  Used for location info.-           -> [Located String] -- ^ Parsed options.-getOptions dflags buf filename-    = getOptions' dflags (getToks dflags filename buf)---- The token parser is written manually because Happy can't--- return a partial result when it encounters a lexer error.--- We want to extract options before the buffer is passed through--- CPP, so we can't use the same trick as 'getImports'.-getOptions' :: DynFlags-            -> [Located Token]      -- Input buffer-            -> [Located String]     -- Options.-getOptions' dflags toks-    = parseToks toks-    where-          parseToks (open:close:xs)-              | IToptions_prag str <- unLoc open-              , ITclose_prag       <- unLoc close-              = case toArgs str of-                  Left _err -> optionsParseError str dflags $   -- #15053-                                 combineSrcSpans (getLoc open) (getLoc close)-                  Right args -> map (L (getLoc open)) args ++ parseToks xs-          parseToks (open:close:xs)-              | ITinclude_prag str <- unLoc open-              , ITclose_prag       <- unLoc close-              = map (L (getLoc open)) ["-#include",removeSpaces str] ++-                parseToks xs-          parseToks (open:close:xs)-              | ITdocOptions str <- unLoc open-              , ITclose_prag     <- unLoc close-              = map (L (getLoc open)) ["-haddock-opts", removeSpaces str]-                ++ parseToks xs-          parseToks (open:xs)-              | ITlanguage_prag <- unLoc open-              = parseLanguage xs-          parseToks (comment:xs) -- Skip over comments-              | isComment (unLoc comment)-              = parseToks xs-          parseToks _ = []-          parseLanguage ((L loc (ITconid fs)):rest)-              = checkExtension dflags (L loc fs) :-                case rest of-                  (L _loc ITcomma):more -> parseLanguage more-                  (L _loc ITclose_prag):more -> parseToks more-                  (L loc _):_ -> languagePragParseError dflags loc-                  [] -> panic "getOptions'.parseLanguage(1) went past eof token"-          parseLanguage (tok:_)-              = languagePragParseError dflags (getLoc tok)-          parseLanguage []-              = panic "getOptions'.parseLanguage(2) went past eof token"--          isComment :: Token -> Bool-          isComment c =-            case c of-              (ITlineComment {})     -> True-              (ITblockComment {})    -> True-              (ITdocCommentNext {})  -> True-              (ITdocCommentPrev {})  -> True-              (ITdocCommentNamed {}) -> True-              (ITdocSection {})      -> True-              _                      -> False----------------------------------------------------------------------------------- | Complain about non-dynamic flags in OPTIONS pragmas.------ Throws a 'SourceError' if the input list is non-empty claiming that the--- input flags are unknown.-checkProcessArgsResult :: MonadIO m => DynFlags -> [Located String] -> m ()-checkProcessArgsResult dflags flags-  = when (notNull flags) $-      liftIO $ throwIO $ mkSrcErr $ listToBag $ map mkMsg flags-    where mkMsg (L loc flag)-              = mkPlainErrMsg dflags loc $-                  (text "unknown flag in  {-# OPTIONS_GHC #-} pragma:" <+>-                   text flag)---------------------------------------------------------------------------------checkExtension :: DynFlags -> Located FastString -> Located String-checkExtension dflags (L l ext)--- Checks if a given extension is valid, and if so returns--- its corresponding flag. Otherwise it throws an exception.-  = if ext' `elem` supported-    then L l ("-X"++ext')-    else unsupportedExtnError dflags l ext'-  where-    ext' = unpackFS ext-    supported = supportedLanguagesAndExtensions $ platformMini $ targetPlatform dflags--languagePragParseError :: DynFlags -> SrcSpan -> a-languagePragParseError dflags loc =-    throwErr dflags loc $-       vcat [ text "Cannot parse LANGUAGE pragma"-            , text "Expecting comma-separated list of language options,"-            , text "each starting with a capital letter"-            , nest 2 (text "E.g. {-# LANGUAGE TemplateHaskell, GADTs #-}") ]--unsupportedExtnError :: DynFlags -> SrcSpan -> String -> a-unsupportedExtnError dflags loc unsup =-    throwErr dflags loc $-        text "Unsupported extension: " <> text unsup $$-        if null suggestions then Outputable.empty else text "Perhaps you meant" <+> quotedListWithOr (map text suggestions)-  where-     supported = supportedLanguagesAndExtensions $ platformMini $ targetPlatform dflags-     suggestions = fuzzyMatch unsup supported---optionsErrorMsgs :: DynFlags -> [String] -> [Located String] -> FilePath -> Messages-optionsErrorMsgs dflags unhandled_flags flags_lines _filename-  = (emptyBag, listToBag (map mkMsg unhandled_flags_lines))-  where unhandled_flags_lines :: [Located String]-        unhandled_flags_lines = [ L l f-                                | f <- unhandled_flags-                                , L l f' <- flags_lines-                                , f == f' ]-        mkMsg (L flagSpan flag) =-            ErrUtils.mkPlainErrMsg dflags flagSpan $-                    text "unknown flag in  {-# OPTIONS_GHC #-} pragma:" <+> text flag--optionsParseError :: String -> DynFlags -> SrcSpan -> a     -- #15053-optionsParseError str dflags loc =-  throwErr dflags loc $-      vcat [ text "Error while parsing OPTIONS_GHC pragma."-           , text "Expecting whitespace-separated list of GHC options."-           , text "  E.g. {-# OPTIONS_GHC -Wall -O2 #-}"-           , text ("Input was: " ++ show str) ]--throwErr :: DynFlags -> SrcSpan -> SDoc -> a                -- #15053-throwErr dflags loc doc =-  throw $ mkSrcErr $ unitBag $ mkPlainErrMsg dflags loc doc
− compiler/main/PlatformConstants.hs 
@@ -1,17 +0,0 @@-{-# LANGUAGE CPP #-}--------------------------------------------------------------------------------------- | Platform constants------ (c) The University of Glasgow 2013-------------------------------------------------------------------------------------module PlatformConstants (PlatformConstants(..)) where--import GhcPrelude---- Produced by deriveConstants-#include "GHCConstantsHaskellType.hs"-
− compiler/main/Settings.hs 
@@ -1,203 +0,0 @@-module Settings-  ( 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-  ) where--import GhcPrelude--import CliOption-import Fingerprint-import FileSettings-import GhcNameVersion-import GHC.Platform-import PlatformConstants-import ToolSettings--data Settings = Settings-  { sGhcNameVersion    :: {-# UNPACk #-} !GhcNameVersion-  , sFileSettings      :: {-# UNPACK #-} !FileSettings-  , sTargetPlatform    :: Platform       -- Filled in by SysTools-  , sToolSettings      :: {-# UNPACK #-} !ToolSettings-  , sPlatformMisc      :: {-# UNPACK #-} !PlatformMisc-  , sPlatformConstants :: PlatformConstants--  -- You shouldn't need to look things up in rawSettings directly.-  -- They should have their own fields instead.-  , sRawSettings       :: [(String, String)]-  }---------------------------------------------------------------------------------- Accessessors from 'Settings'--sProgramName         :: Settings -> String-sProgramName = ghcNameVersion_programName . sGhcNameVersion-sProjectVersion      :: Settings -> String-sProjectVersion = ghcNameVersion_projectVersion . sGhcNameVersion--sGhcUsagePath        :: Settings -> FilePath-sGhcUsagePath = fileSettings_ghcUsagePath . sFileSettings-sGhciUsagePath       :: Settings -> FilePath-sGhciUsagePath = fileSettings_ghciUsagePath . sFileSettings-sToolDir             :: Settings -> Maybe FilePath-sToolDir = fileSettings_toolDir . sFileSettings-sTopDir              :: Settings -> FilePath-sTopDir = fileSettings_topDir . sFileSettings-sTmpDir              :: Settings -> String-sTmpDir = fileSettings_tmpDir . sFileSettings-sGlobalPackageDatabasePath :: Settings -> FilePath-sGlobalPackageDatabasePath = fileSettings_globalPackageDatabase . sFileSettings--sLdSupportsCompactUnwind :: Settings -> Bool-sLdSupportsCompactUnwind = toolSettings_ldSupportsCompactUnwind . sToolSettings-sLdSupportsBuildId :: Settings -> Bool-sLdSupportsBuildId = toolSettings_ldSupportsBuildId . sToolSettings-sLdSupportsFilelist :: Settings -> Bool-sLdSupportsFilelist = toolSettings_ldSupportsFilelist . sToolSettings-sLdIsGnuLd :: Settings -> Bool-sLdIsGnuLd = toolSettings_ldIsGnuLd . sToolSettings-sGccSupportsNoPie :: Settings -> Bool-sGccSupportsNoPie = toolSettings_ccSupportsNoPie . sToolSettings--sPgm_L :: Settings -> String-sPgm_L = toolSettings_pgm_L . sToolSettings-sPgm_P :: Settings -> (String, [Option])-sPgm_P = toolSettings_pgm_P . sToolSettings-sPgm_F :: Settings -> String-sPgm_F = toolSettings_pgm_F . sToolSettings-sPgm_c :: Settings -> String-sPgm_c = toolSettings_pgm_c . sToolSettings-sPgm_a :: Settings -> (String, [Option])-sPgm_a = toolSettings_pgm_a . sToolSettings-sPgm_l :: Settings -> (String, [Option])-sPgm_l = toolSettings_pgm_l . sToolSettings-sPgm_dll :: Settings -> (String, [Option])-sPgm_dll = toolSettings_pgm_dll . sToolSettings-sPgm_T :: Settings -> String-sPgm_T = toolSettings_pgm_T . sToolSettings-sPgm_windres :: Settings -> String-sPgm_windres = toolSettings_pgm_windres . sToolSettings-sPgm_libtool :: Settings -> String-sPgm_libtool = toolSettings_pgm_libtool . sToolSettings-sPgm_ar :: Settings -> String-sPgm_ar = toolSettings_pgm_ar . sToolSettings-sPgm_ranlib :: Settings -> String-sPgm_ranlib = toolSettings_pgm_ranlib . sToolSettings-sPgm_lo :: Settings -> (String, [Option])-sPgm_lo = toolSettings_pgm_lo . sToolSettings-sPgm_lc :: Settings -> (String, [Option])-sPgm_lc = toolSettings_pgm_lc . sToolSettings-sPgm_lcc :: Settings -> (String, [Option])-sPgm_lcc = toolSettings_pgm_lcc . sToolSettings-sPgm_i :: Settings -> String-sPgm_i = toolSettings_pgm_i . sToolSettings-sOpt_L :: Settings -> [String]-sOpt_L = toolSettings_opt_L . sToolSettings-sOpt_P :: Settings -> [String]-sOpt_P = toolSettings_opt_P . sToolSettings-sOpt_P_fingerprint :: Settings -> Fingerprint-sOpt_P_fingerprint = toolSettings_opt_P_fingerprint . sToolSettings-sOpt_F :: Settings -> [String]-sOpt_F = toolSettings_opt_F . sToolSettings-sOpt_c :: Settings -> [String]-sOpt_c = toolSettings_opt_c . sToolSettings-sOpt_cxx :: Settings -> [String]-sOpt_cxx = toolSettings_opt_cxx . sToolSettings-sOpt_a :: Settings -> [String]-sOpt_a = toolSettings_opt_a . sToolSettings-sOpt_l :: Settings -> [String]-sOpt_l = toolSettings_opt_l . sToolSettings-sOpt_windres :: Settings -> [String]-sOpt_windres = toolSettings_opt_windres . sToolSettings-sOpt_lo :: Settings -> [String]-sOpt_lo = toolSettings_opt_lo . sToolSettings-sOpt_lc :: Settings -> [String]-sOpt_lc = toolSettings_opt_lc . sToolSettings-sOpt_lcc :: Settings -> [String]-sOpt_lcc = toolSettings_opt_lcc . sToolSettings-sOpt_i :: Settings -> [String]-sOpt_i = toolSettings_opt_i . sToolSettings--sExtraGccViaCFlags :: Settings -> [String]-sExtraGccViaCFlags = toolSettings_extraGccViaCFlags . sToolSettings--sTargetPlatformString :: Settings -> String-sTargetPlatformString = platformMisc_targetPlatformString . sPlatformMisc-sIntegerLibrary :: Settings -> String-sIntegerLibrary = platformMisc_integerLibrary . sPlatformMisc-sIntegerLibraryType :: Settings -> IntegerLibrary-sIntegerLibraryType = platformMisc_integerLibraryType . sPlatformMisc-sGhcWithInterpreter :: Settings -> Bool-sGhcWithInterpreter = platformMisc_ghcWithInterpreter . sPlatformMisc-sGhcWithNativeCodeGen :: Settings -> Bool-sGhcWithNativeCodeGen = platformMisc_ghcWithNativeCodeGen . sPlatformMisc-sGhcWithSMP :: Settings -> Bool-sGhcWithSMP = platformMisc_ghcWithSMP . sPlatformMisc-sGhcRTSWays :: Settings -> String-sGhcRTSWays = platformMisc_ghcRTSWays . sPlatformMisc-sTablesNextToCode :: Settings -> Bool-sTablesNextToCode = platformMisc_tablesNextToCode . sPlatformMisc-sLeadingUnderscore :: Settings -> Bool-sLeadingUnderscore = platformMisc_leadingUnderscore . sPlatformMisc-sLibFFI :: Settings -> Bool-sLibFFI = platformMisc_libFFI . sPlatformMisc-sGhcThreaded :: Settings -> Bool-sGhcThreaded = platformMisc_ghcThreaded . sPlatformMisc-sGhcDebugged :: Settings -> Bool-sGhcDebugged = platformMisc_ghcDebugged . sPlatformMisc-sGhcRtsWithLibdw :: Settings -> Bool-sGhcRtsWithLibdw = platformMisc_ghcRtsWithLibdw . sPlatformMisc
− compiler/main/SysTools/BaseDir.hs 
@@ -1,137 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE ScopedTypeVariables #-}--{------------------------------------------------------------------------------------- (c) The University of Glasgow 2001-2017------ Finding the compiler's base directory.-----------------------------------------------------------------------------------}--module SysTools.BaseDir-  ( expandTopDir, expandToolDir-  , findTopDir, findToolDir-  , tryFindTopDir-  ) where--#include "HsVersions.h"--import GhcPrelude---- See note [Base Dir] for why some of this logic is shared with ghc-pkg.-import GHC.BaseDir--import Panic--import System.Environment (lookupEnv)-import System.FilePath---- Windows-#if defined(mingw32_HOST_OS)-import System.Directory (doesDirectoryExist)-#endif--#if defined(mingw32_HOST_OS)-# if defined(i386_HOST_ARCH)-#  define WINDOWS_CCONV stdcall-# elif defined(x86_64_HOST_ARCH)-#  define WINDOWS_CCONV ccall-# else-#  error Unknown mingw32 arch-# endif-#endif--{--Note [topdir: How GHC finds its files]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--GHC needs various support files (library packages, RTS etc), plus-various auxiliary programs (cp, gcc, etc).  It starts by finding topdir,-the root of GHC's support files--On Unix:-  - ghc always has a shell wrapper that passes a -B<dir> option--On Windows:-  - ghc never has a shell wrapper.-  - we can find the location of the ghc binary, which is-        $topdir/<foo>/<something>.exe-    where <something> may be "ghc", "ghc-stage2", or similar-  - we strip off the "<foo>/<something>.exe" to leave $topdir.--from topdir we can find package.conf, ghc-asm, etc.---Note [tooldir: How GHC finds mingw on Windows]--GHC has some custom logic on Windows for finding the mingw-toolchain and perl. Depending on whether GHC is built-with the make build system or Hadrian, and on whether we're-running a bindist, we might find the mingw toolchain and perl-either under $topdir/../{mingw, perl}/ or-$topdir/../../{mingw, perl}/.---}---- | Expand occurrences of the @$tooldir@ interpolation in a string--- on Windows, leave the string untouched otherwise.-expandToolDir :: Maybe FilePath -> String -> String-#if defined(mingw32_HOST_OS)-expandToolDir (Just tool_dir) s = expandPathVar "tooldir" tool_dir s-expandToolDir Nothing         _ = panic "Could not determine $tooldir"-#else-expandToolDir _ s = s-#endif---- | Returns a Unix-format path pointing to TopDir.-findTopDir :: Maybe String -- Maybe TopDir path (without the '-B' prefix).-           -> IO String    -- TopDir (in Unix format '/' separated)-findTopDir m_minusb = do-  maybe_exec_dir <- tryFindTopDir m_minusb-  case maybe_exec_dir of-      -- "Just" on Windows, "Nothing" on unix-      Nothing -> throwGhcExceptionIO $-          InstallationError "missing -B<dir> option"-      Just dir -> return dir--tryFindTopDir-  :: Maybe String -- ^ Maybe TopDir path (without the '-B' prefix).-  -> IO (Maybe String) -- ^ TopDir (in Unix format '/' separated)-tryFindTopDir (Just minusb) = return $ Just $ normalise minusb-tryFindTopDir Nothing-    = do -- The _GHC_TOP_DIR environment variable can be used to specify-         -- the top dir when the -B argument is not specified. It is not-         -- intended for use by users, it was added specifically for the-         -- purpose of running GHC within GHCi.-         maybe_env_top_dir <- lookupEnv "_GHC_TOP_DIR"-         case maybe_env_top_dir of-             Just env_top_dir -> return $ Just env_top_dir-             -- Try directory of executable-             Nothing -> getBaseDir----- See Note [tooldir: How GHC finds mingw and perl on Windows]--- Returns @Nothing@ when not on Windows.--- When called on Windows, it either throws an error when the--- tooldir can't be located, or returns @Just tooldirpath@.-findToolDir-  :: FilePath -- ^ topdir-  -> IO (Maybe FilePath)-#if defined(mingw32_HOST_OS)-findToolDir top_dir = go 0 (top_dir </> "..")-  where maxDepth = 3-        go :: Int -> FilePath -> IO (Maybe FilePath)-        go k path-          | k == maxDepth = throwGhcExceptionIO $-              InstallationError "could not detect mingw toolchain"-          | otherwise = do-              oneLevel <- doesDirectoryExist (path </> "mingw")-              if oneLevel-                then return (Just path)-                else go (k+1) (path </> "..")-#else-findToolDir _ = return Nothing-#endif
− compiler/main/SysTools/Terminal.hs 
@@ -1,96 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE ScopedTypeVariables #-}-module SysTools.Terminal (stderrSupportsAnsiColors) where--import GhcPrelude--#if defined(MIN_VERSION_terminfo)-import Control.Exception (catch)-import Data.Maybe (fromMaybe)-import System.Console.Terminfo (SetupTermError, Terminal, getCapability,-                                setupTermFromEnv, termColors)-import System.Posix (queryTerminal, stdError)-#elif defined(mingw32_HOST_OS)-import Control.Exception (catch, try)-import Data.Bits ((.|.), (.&.))-import Foreign (Ptr, peek, with)-import qualified Graphics.Win32 as Win32-import qualified System.Win32 as Win32-#endif--#if defined(mingw32_HOST_OS) && !defined(WINAPI)-# if defined(i386_HOST_ARCH)-#  define WINAPI stdcall-# elif defined(x86_64_HOST_ARCH)-#  define WINAPI ccall-# else-#  error unknown architecture-# endif-#endif---- | Check if ANSI escape sequences can be used to control color in stderr.-stderrSupportsAnsiColors :: IO Bool-stderrSupportsAnsiColors = do-#if defined(MIN_VERSION_terminfo)-    stderr_available <- queryTerminal stdError-    if stderr_available then-      fmap termSupportsColors setupTermFromEnv-        `catch` \ (_ :: SetupTermError) -> pure False-    else-      pure False-  where-    termSupportsColors :: Terminal -> Bool-    termSupportsColors term = fromMaybe 0 (getCapability term termColors) > 0--#elif defined(mingw32_HOST_OS)-  h <- Win32.getStdHandle Win32.sTD_ERROR_HANDLE-         `catch` \ (_ :: IOError) ->-           pure Win32.nullHANDLE-  if h == Win32.nullHANDLE-    then pure False-    else do-      eMode <- try (getConsoleMode h)-      case eMode of-        Left (_ :: IOError) -> Win32.isMinTTYHandle h-                                 -- Check if the we're in a MinTTY terminal-                                 -- (e.g., Cygwin or MSYS2)-        Right mode-          | modeHasVTP mode -> pure True-          | otherwise       -> enableVTP h mode--  where--    enableVTP :: Win32.HANDLE -> Win32.DWORD -> IO Bool-    enableVTP h mode = do-        setConsoleMode h (modeAddVTP mode)-        modeHasVTP <$> getConsoleMode h-      `catch` \ (_ :: IOError) ->-        pure False--    modeHasVTP :: Win32.DWORD -> Bool-    modeHasVTP mode = mode .&. eNABLE_VIRTUAL_TERMINAL_PROCESSING /= 0--    modeAddVTP :: Win32.DWORD -> Win32.DWORD-    modeAddVTP mode = mode .|. eNABLE_VIRTUAL_TERMINAL_PROCESSING--eNABLE_VIRTUAL_TERMINAL_PROCESSING :: Win32.DWORD-eNABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004--getConsoleMode :: Win32.HANDLE -> IO Win32.DWORD-getConsoleMode h = with 64 $ \ mode -> do-  Win32.failIfFalse_ "GetConsoleMode" (c_GetConsoleMode h mode)-  peek mode--setConsoleMode :: Win32.HANDLE -> Win32.DWORD -> IO ()-setConsoleMode h mode = do-  Win32.failIfFalse_ "SetConsoleMode" (c_SetConsoleMode h mode)--foreign import WINAPI unsafe "windows.h GetConsoleMode" c_GetConsoleMode-  :: Win32.HANDLE -> Ptr Win32.DWORD -> IO Win32.BOOL--foreign import WINAPI unsafe "windows.h SetConsoleMode" c_SetConsoleMode-  :: Win32.HANDLE -> Win32.DWORD -> IO Win32.BOOL--#else-   pure False-#endif
− compiler/main/ToolSettings.hs 
@@ -1,64 +0,0 @@-module ToolSettings-  ( ToolSettings (..)-  ) where--import GhcPrelude--import CliOption-import Fingerprint---- | Settings for other executables GHC calls.------ Probably should further split down by phase, or split between--- platform-specific and platform-agnostic.-data ToolSettings = ToolSettings-  { toolSettings_ldSupportsCompactUnwind :: Bool-  , toolSettings_ldSupportsBuildId       :: Bool-  , toolSettings_ldSupportsFilelist      :: Bool-  , toolSettings_ldIsGnuLd               :: Bool-  , toolSettings_ccSupportsNoPie         :: Bool--  -- commands for particular phases-  , toolSettings_pgm_L       :: String-  , toolSettings_pgm_P       :: (String, [Option])-  , toolSettings_pgm_F       :: String-  , toolSettings_pgm_c       :: String-  , toolSettings_pgm_a       :: (String, [Option])-  , toolSettings_pgm_l       :: (String, [Option])-  , toolSettings_pgm_dll     :: (String, [Option])-  , toolSettings_pgm_T       :: String-  , toolSettings_pgm_windres :: String-  , toolSettings_pgm_libtool :: String-  , toolSettings_pgm_ar      :: String-  , toolSettings_pgm_ranlib  :: String-  , -- | LLVM: opt llvm optimiser-    toolSettings_pgm_lo      :: (String, [Option])-  , -- | LLVM: llc static compiler-    toolSettings_pgm_lc      :: (String, [Option])-  , -- | LLVM: c compiler-    toolSettings_pgm_lcc     :: (String, [Option])-  , toolSettings_pgm_i       :: String--  -- options for particular phases-  , toolSettings_opt_L             :: [String]-  , toolSettings_opt_P             :: [String]-  , -- | cached Fingerprint of sOpt_P-    -- See Note [Repeated -optP hashing]-    toolSettings_opt_P_fingerprint :: Fingerprint-  , toolSettings_opt_F             :: [String]-  , toolSettings_opt_c             :: [String]-  , toolSettings_opt_cxx           :: [String]-  , toolSettings_opt_a             :: [String]-  , toolSettings_opt_l             :: [String]-  , toolSettings_opt_windres       :: [String]-  , -- | LLVM: llvm optimiser-    toolSettings_opt_lo            :: [String]-  , -- | LLVM: llc static compiler-    toolSettings_opt_lc            :: [String]-  , -- | LLVM: c compiler-    toolSettings_opt_lcc           :: [String]-  , -- | iserv options-    toolSettings_opt_i             :: [String]--  , toolSettings_extraGccViaCFlags :: [String]-  }
− compiler/main/UnitInfo.hs 
@@ -1,157 +0,0 @@-{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, MultiParamTypeClasses #-}---- |--- Package configuration information: essentially the interface to Cabal, with--- some utilities------ (c) The University of Glasgow, 2004----module UnitInfo (-        -- $package_naming--        -- * UnitId-        packageConfigId,-        expandedUnitInfoId,-        definiteUnitInfoId,-        installedUnitInfoId,--        -- * The UnitInfo type: information about a unit-        UnitInfo,-        InstalledPackageInfo(..),-        ComponentId(..),-        SourcePackageId(..),-        PackageName(..),-        Version(..),-        defaultUnitInfo,-        sourcePackageIdString,-        packageNameString,-        pprUnitInfo,-    ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.PackageDb-import Data.Version--import FastString-import Outputable-import GHC.Types.Module as Module-import GHC.Types.Unique---- -------------------------------------------------------------------------------- Our UnitInfo type is the InstalledPackageInfo from ghc-boot,--- which is similar to a subset of the InstalledPackageInfo type from Cabal.--type UnitInfo = InstalledPackageInfo-                       ComponentId-                       SourcePackageId-                       PackageName-                       Module.InstalledUnitId-                       Module.UnitId-                       Module.ModuleName-                       Module.Module---- TODO: there's no need for these to be FastString, as we don't need the uniq---       feature, but ghc doesn't currently have convenient support for any---       other compact string types, e.g. plain ByteString or Text.--newtype SourcePackageId    = SourcePackageId    FastString deriving (Eq, Ord)-newtype PackageName = PackageName-   { unPackageName :: FastString-   }-   deriving (Eq, Ord)--instance BinaryStringRep SourcePackageId where-  fromStringRep = SourcePackageId . mkFastStringByteString-  toStringRep (SourcePackageId s) = bytesFS s--instance BinaryStringRep PackageName where-  fromStringRep = PackageName . mkFastStringByteString-  toStringRep (PackageName s) = bytesFS s--instance Uniquable SourcePackageId where-  getUnique (SourcePackageId n) = getUnique n--instance Uniquable PackageName where-  getUnique (PackageName n) = getUnique n--instance Outputable SourcePackageId where-  ppr (SourcePackageId str) = ftext str--instance Outputable PackageName where-  ppr (PackageName str) = ftext str--defaultUnitInfo :: UnitInfo-defaultUnitInfo = emptyInstalledPackageInfo--sourcePackageIdString :: UnitInfo -> String-sourcePackageIdString pkg = unpackFS str-  where-    SourcePackageId str = sourcePackageId pkg--packageNameString :: UnitInfo -> String-packageNameString pkg = unpackFS str-  where-    PackageName str = packageName pkg--pprUnitInfo :: UnitInfo -> SDoc-pprUnitInfo InstalledPackageInfo {..} =-    vcat [-      field "name"                 (ppr packageName),-      field "version"              (text (showVersion packageVersion)),-      field "id"                   (ppr unitId),-      field "exposed"              (ppr exposed),-      field "exposed-modules"      (ppr exposedModules),-      field "hidden-modules"       (fsep (map ppr hiddenModules)),-      field "trusted"              (ppr trusted),-      field "import-dirs"          (fsep (map text importDirs)),-      field "library-dirs"         (fsep (map text libraryDirs)),-      field "dynamic-library-dirs" (fsep (map text libraryDynDirs)),-      field "hs-libraries"         (fsep (map text hsLibraries)),-      field "extra-libraries"      (fsep (map text extraLibraries)),-      field "extra-ghci-libraries" (fsep (map text extraGHCiLibraries)),-      field "include-dirs"         (fsep (map text includeDirs)),-      field "includes"             (fsep (map text includes)),-      field "depends"              (fsep (map ppr  depends)),-      field "cc-options"           (fsep (map text ccOptions)),-      field "ld-options"           (fsep (map text ldOptions)),-      field "framework-dirs"       (fsep (map text frameworkDirs)),-      field "frameworks"           (fsep (map text frameworks)),-      field "haddock-interfaces"   (fsep (map text haddockInterfaces)),-      field "haddock-html"         (fsep (map text haddockHTMLs))-    ]-  where-    field name body = text name <> colon <+> nest 4 body---- -------------------------------------------------------------------------------- UnitId (package names, versions and dep hash)---- $package_naming--- #package_naming#--- Mostly the compiler deals in terms of 'UnitId's, which are md5 hashes--- of a package ID, keys of its dependencies, and Cabal flags. You're expected--- to pass in the unit id in the @-this-unit-id@ flag. However, for--- wired-in packages like @base@ & @rts@, we don't necessarily know what the--- version is, so these are handled specially; see #wired_in_packages#.---- | Get the GHC 'UnitId' right out of a Cabalish 'UnitInfo'-installedUnitInfoId :: UnitInfo -> InstalledUnitId-installedUnitInfoId = unitId--packageConfigId :: UnitInfo -> UnitId-packageConfigId p =-    if indefinite p-        then newUnitId (componentId p) (instantiatedWith p)-        else DefiniteUnitId (DefUnitId (unitId p))--expandedUnitInfoId :: UnitInfo -> UnitId-expandedUnitInfoId p =-    newUnitId (componentId p) (instantiatedWith p)--definiteUnitInfoId :: UnitInfo -> Maybe DefUnitId-definiteUnitInfoId p =-    case packageConfigId p of-        DefiniteUnitId def_uid -> Just def_uid-        _ -> Nothing
− compiler/parser/ApiAnnotation.hs 
@@ -1,378 +0,0 @@-{-# LANGUAGE DeriveDataTypeable #-}--module ApiAnnotation (-  getAnnotation, getAndRemoveAnnotation,-  getAnnotationComments,getAndRemoveAnnotationComments,-  ApiAnns(..),-  ApiAnnKey,-  AnnKeywordId(..),-  AnnotationComment(..),-  IsUnicodeSyntax(..),-  unicodeAnn,-  HasE(..),-  LRdrName -- Exists for haddocks only-  ) where--import GhcPrelude--import GHC.Types.Name.Reader-import Outputable-import GHC.Types.SrcLoc-import qualified Data.Map as Map-import Data.Data---{--Note [Api annotations]-~~~~~~~~~~~~~~~~~~~~~~-Given a parse tree of a Haskell module, how can we reconstruct-the original Haskell source code, retaining all whitespace and-source code comments?  We need to track the locations of all-elements from the original source: this includes keywords such as-'let' / 'in' / 'do' etc as well as punctuation such as commas and-braces, and also comments.  We collectively refer to this-metadata as the "API annotations".--Rather than annotate the resulting parse tree with these locations-directly (this would be a major change to some fairly core data-structures in GHC), we instead capture locations for these elements in a-structure separate from the parse tree, and returned in the-pm_annotations field of the ParsedModule type.--The full ApiAnns type is--> data ApiAnns =->  ApiAnns->    { apiAnnItems :: Map.Map ApiAnnKey [RealSrcSpan],->      apiAnnEofPos :: Maybe RealSrcSpan,->      apiAnnComments :: Map.Map RealSrcSpan [RealLocated AnnotationComment],->      apiAnnRogueComments :: [RealLocated AnnotationComment]->    }--NON-COMMENT ELEMENTS--Intuitively, every AST element directly contains a bag of keywords-(keywords can show up more than once in a node: a semicolon i.e. newline-can show up multiple times before the next AST element), each of which-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 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 = (RealSrcSpan,AnnKeywordId)->-> Map.Map ApiAnnKey [RealSrcSpan]--So--> let x = 1 in 2 *x--would result in the AST element--  L span (HsLet (binds for x = 1) (2 * x))--and the annotations--  (span,AnnLet) having the location of the 'let' keyword-  (span,AnnEqual) having the location of the '=' sign-  (span,AnnIn)  having the location of the 'in' keyword--For any given element in the AST, there is only a set number of-keywords that are applicable for it (e.g., you'll never see an-'import' keyword associated with a let-binding.)  The set of allowed-keywords is documented in a comment associated with the constructor-of a given AST element, although the ground truth is in Parser-and RdrHsSyn (which actually add the annotations; see #13012).--COMMENT ELEMENTS--Every comment is associated with a *located* AnnotationComment.-We associate comments with the lowest (most specific) AST element-enclosing them:--> Map.Map RealSrcSpan [RealLocated AnnotationComment]--PARSER STATE--There are three fields in PState (the parser state) which play a role-with annotations.-->  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-(after they are passed to Map.fromList).--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 RealSrcSpan in-annotations_comments).--PARSER EMISSION OF ANNOTATIONS--The parser interacts with the lexer using the function--> addAnnotation :: RealSrcSpan -> AnnKeywordId -> RealSrcSpan -> P ()--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 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'.)--The wiki page describing this feature is-https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations---}--- ------------------------------------------------------------------------- If you update this, update the Note [Api annotations] above-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 = (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 -> 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 -> 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 -> 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 -> 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---- ------------------------------------------------------------------------ | API Annotations exist so that tools can perform source to source--- conversions of Haskell code. They are used to keep track of the--- various syntactic keywords that are not captured in the existing--- AST.------ The annotations, together with original source comments are made--- available in the @'pm_annotations'@ field of @'GHC.ParsedModule'@.--- Comments are only retained if @'Opt_KeepRawTokenStream'@ is set in--- @'DynFlags.DynFlags'@ before parsing.------ The wiki page describing this feature is--- https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations------ Note: in general the names of these are taken from the--- corresponding token, unless otherwise noted--- See note [Api annotations] above for details of the usage-data AnnKeywordId-    = AnnAnyclass-    | AnnAs-    | AnnAt-    | AnnBang  -- ^ '!'-    | AnnBackquote -- ^ '`'-    | AnnBy-    | AnnCase -- ^ case or lambda case-    | AnnClass-    | AnnClose -- ^  '\#)' or '\#-}'  etc-    | AnnCloseB -- ^ '|)'-    | AnnCloseBU -- ^ '|)', unicode variant-    | AnnCloseC -- ^ '}'-    | AnnCloseQ  -- ^ '|]'-    | AnnCloseQU -- ^ '|]', unicode variant-    | AnnCloseP -- ^ ')'-    | AnnCloseS -- ^ ']'-    | AnnColon-    | AnnComma -- ^ as a list separator-    | AnnCommaTuple -- ^ in a RdrName for a tuple-    | AnnDarrow -- ^ '=>'-    | AnnDarrowU -- ^ '=>', unicode variant-    | AnnData-    | AnnDcolon -- ^ '::'-    | AnnDcolonU -- ^ '::', unicode variant-    | AnnDefault-    | AnnDeriving-    | AnnDo-    | AnnDot    -- ^ '.'-    | AnnDotdot -- ^ '..'-    | AnnElse-    | AnnEqual-    | AnnExport-    | AnnFamily-    | AnnForall-    | AnnForallU -- ^ Unicode variant-    | AnnForeign-    | AnnFunId -- ^ for function name in matches where there are-               -- multiple equations for the function.-    | AnnGroup-    | AnnHeader -- ^ for CType-    | AnnHiding-    | AnnIf-    | AnnImport-    | AnnIn-    | AnnInfix -- ^ 'infix' or 'infixl' or 'infixr'-    | AnnInstance-    | AnnLam-    | AnnLarrow     -- ^ '<-'-    | AnnLarrowU    -- ^ '<-', unicode variant-    | AnnLet-    | AnnMdo-    | AnnMinus -- ^ '-'-    | AnnModule-    | AnnNewtype-    | AnnName -- ^ where a name loses its location in the AST, this carries it-    | AnnOf-    | AnnOpen    -- ^ '(\#' or '{-\# LANGUAGE' etc-    | AnnOpenB   -- ^ '(|'-    | AnnOpenBU  -- ^ '(|', unicode variant-    | AnnOpenC   -- ^ '{'-    | AnnOpenE   -- ^ '[e|' or '[e||'-    | AnnOpenEQ  -- ^ '[|'-    | AnnOpenEQU -- ^ '[|', unicode variant-    | AnnOpenP   -- ^ '('-    | AnnOpenS   -- ^ '['-    | AnnDollar          -- ^ prefix '$'   -- TemplateHaskell-    | AnnDollarDollar    -- ^ prefix '$$'  -- TemplateHaskell-    | AnnPackageName-    | AnnPattern-    | AnnProc-    | AnnQualified-    | AnnRarrow -- ^ '->'-    | AnnRarrowU -- ^ '->', unicode variant-    | AnnRec-    | AnnRole-    | AnnSafe-    | AnnSemi -- ^ ';'-    | AnnSimpleQuote -- ^ '''-    | AnnSignature-    | AnnStatic -- ^ 'static'-    | AnnStock-    | AnnThen-    | AnnThIdSplice -- ^ '$'-    | AnnThIdTySplice -- ^ '$$'-    | AnnThTyQuote -- ^ double '''-    | AnnTilde -- ^ '~'-    | AnnType-    | AnnUnit -- ^ '()' for types-    | AnnUsing-    | AnnVal  -- ^ e.g. INTEGER-    | AnnValStr  -- ^ String value, will need quotes when output-    | AnnVbar -- ^ '|'-    | AnnVia -- ^ 'via'-    | AnnWhere-    | Annlarrowtail -- ^ '-<'-    | AnnlarrowtailU -- ^ '-<', unicode variant-    | Annrarrowtail -- ^ '->'-    | AnnrarrowtailU -- ^ '->', unicode variant-    | AnnLarrowtail -- ^ '-<<'-    | AnnLarrowtailU -- ^ '-<<', unicode variant-    | AnnRarrowtail -- ^ '>>-'-    | AnnRarrowtailU -- ^ '>>-', unicode variant-    deriving (Eq, Ord, Data, Show)--instance Outputable AnnKeywordId where-  ppr x = text (show x)---- -----------------------------------------------------------------------data AnnotationComment =-  -- Documentation annotations-    AnnDocCommentNext  String     -- ^ something beginning '-- |'-  | AnnDocCommentPrev  String     -- ^ something beginning '-- ^'-  | AnnDocCommentNamed String     -- ^ something beginning '-- $'-  | AnnDocSection      Int String -- ^ a section heading-  | AnnDocOptions      String     -- ^ doc options (prune, ignore-exports, etc)-  | AnnLineComment     String     -- ^ comment starting by "--"-  | AnnBlockComment    String     -- ^ comment in {- -}-    deriving (Eq, Ord, Data, Show)--- Note: these are based on the Token versions, but the Token type is--- defined in Lexer.x and bringing it in here would create a loop--instance Outputable AnnotationComment where-  ppr x = text (show x)---- | - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',---             'ApiAnnotation.AnnClose','ApiAnnotation.AnnComma',---             'ApiAnnotation.AnnRarrow'---             'ApiAnnotation.AnnTilde'---   - May have 'ApiAnnotation.AnnComma' when in a list-type LRdrName = Located RdrName----- | Certain tokens can have alternate representations when unicode syntax is--- enabled. This flag is attached to those tokens in the lexer so that the--- original source representation can be reproduced in the corresponding--- 'ApiAnnotation'-data IsUnicodeSyntax = UnicodeSyntax | NormalSyntax-    deriving (Eq, Ord, Data, Show)---- | Convert a normal annotation into its unicode equivalent one-unicodeAnn :: AnnKeywordId -> AnnKeywordId-unicodeAnn AnnForall     = AnnForallU-unicodeAnn AnnDcolon     = AnnDcolonU-unicodeAnn AnnLarrow     = AnnLarrowU-unicodeAnn AnnRarrow     = AnnRarrowU-unicodeAnn AnnDarrow     = AnnDarrowU-unicodeAnn Annlarrowtail = AnnlarrowtailU-unicodeAnn Annrarrowtail = AnnrarrowtailU-unicodeAnn AnnLarrowtail = AnnLarrowtailU-unicodeAnn AnnRarrowtail = AnnRarrowtailU-unicodeAnn AnnOpenB      = AnnOpenBU-unicodeAnn AnnCloseB     = AnnCloseBU-unicodeAnn AnnOpenEQ     = AnnOpenEQU-unicodeAnn AnnCloseQ     = AnnCloseQU-unicodeAnn ann           = ann----- | Some template haskell tokens have two variants, one with an `e` the other--- not:------ >  [| or [e|--- >  [|| or [e||------ This type indicates whether the 'e' is present or not.-data HasE = HasE | NoE-     deriving (Eq, Ord, Data, Show)
− compiler/parser/Ctype.hs 
@@ -1,215 +0,0 @@--- Character classification-{-# LANGUAGE CPP #-}-module Ctype-        ( is_ident      -- Char# -> Bool-        , is_symbol     -- Char# -> Bool-        , is_any        -- Char# -> Bool-        , is_space      -- Char# -> Bool-        , is_lower      -- Char# -> Bool-        , is_upper      -- Char# -> Bool-        , is_digit      -- Char# -> Bool-        , is_alphanum   -- Char# -> Bool--        , is_decdigit, is_hexdigit, is_octdigit, is_bindigit-        , hexDigit, octDecDigit-        ) where--#include "HsVersions.h"--import GhcPrelude--import Data.Bits        ( Bits((.&.),(.|.)) )-import Data.Char        ( ord, chr )-import Data.Word-import Panic---- Bit masks--cIdent, cSymbol, cAny, cSpace, cLower, cUpper, cDigit :: Word8-cIdent  =  1-cSymbol =  2-cAny    =  4-cSpace  =  8-cLower  = 16-cUpper  = 32-cDigit  = 64---- | The predicates below look costly, but aren't, GHC+GCC do a great job--- at the big case below.--{-# INLINABLE is_ctype #-}-is_ctype :: Word8 -> Char -> Bool-is_ctype mask c = (charType c .&. mask) /= 0--is_ident, is_symbol, is_any, is_space, is_lower, is_upper, is_digit,-    is_alphanum :: Char -> Bool-is_ident  = is_ctype cIdent-is_symbol = is_ctype cSymbol-is_any    = is_ctype cAny-is_space  = is_ctype cSpace-is_lower  = is_ctype cLower-is_upper  = is_ctype cUpper-is_digit  = is_ctype cDigit-is_alphanum = is_ctype (cLower+cUpper+cDigit)---- Utils--hexDigit :: Char -> Int-hexDigit c | is_decdigit c = ord c - ord '0'-           | otherwise     = ord (to_lower c) - ord 'a' + 10--octDecDigit :: Char -> Int-octDecDigit c = ord c - ord '0'--is_decdigit :: Char -> Bool-is_decdigit c-        =  c >= '0' && c <= '9'--is_hexdigit :: Char -> Bool-is_hexdigit c-        =  is_decdigit c-        || (c >= 'a' && c <= 'f')-        || (c >= 'A' && c <= 'F')--is_octdigit :: Char -> Bool-is_octdigit c = c >= '0' && c <= '7'--is_bindigit :: Char -> Bool-is_bindigit c = c == '0' || c == '1'--to_lower :: Char -> Char-to_lower c-  | c >=  'A' && c <= 'Z' = chr (ord c - (ord 'A' - ord 'a'))-  | otherwise = c--charType :: Char -> Word8-charType c = case c of-   '\0'   -> 0                             -- \000-   '\1'   -> 0                             -- \001-   '\2'   -> 0                             -- \002-   '\3'   -> 0                             -- \003-   '\4'   -> 0                             -- \004-   '\5'   -> 0                             -- \005-   '\6'   -> 0                             -- \006-   '\7'   -> 0                             -- \007-   '\8'   -> 0                             -- \010-   '\9'   -> cSpace                        -- \t  (not allowed in strings, so !cAny)-   '\10'  -> cSpace                        -- \n  (ditto)-   '\11'  -> cSpace                        -- \v  (ditto)-   '\12'  -> cSpace                        -- \f  (ditto)-   '\13'  -> cSpace                        --  ^M (ditto)-   '\14'  -> 0                             -- \016-   '\15'  -> 0                             -- \017-   '\16'  -> 0                             -- \020-   '\17'  -> 0                             -- \021-   '\18'  -> 0                             -- \022-   '\19'  -> 0                             -- \023-   '\20'  -> 0                             -- \024-   '\21'  -> 0                             -- \025-   '\22'  -> 0                             -- \026-   '\23'  -> 0                             -- \027-   '\24'  -> 0                             -- \030-   '\25'  -> 0                             -- \031-   '\26'  -> 0                             -- \032-   '\27'  -> 0                             -- \033-   '\28'  -> 0                             -- \034-   '\29'  -> 0                             -- \035-   '\30'  -> 0                             -- \036-   '\31'  -> 0                             -- \037-   '\32'  -> cAny .|. cSpace               ---   '\33'  -> cAny .|. cSymbol              -- !-   '\34'  -> cAny                          -- "-   '\35'  -> cAny .|. cSymbol              --  #-   '\36'  -> cAny .|. cSymbol              --  $-   '\37'  -> cAny .|. cSymbol              -- %-   '\38'  -> cAny .|. cSymbol              -- &-   '\39'  -> cAny .|. cIdent               -- '-   '\40'  -> cAny                          -- (-   '\41'  -> cAny                          -- )-   '\42'  -> cAny .|. cSymbol              --  *-   '\43'  -> cAny .|. cSymbol              -- +-   '\44'  -> cAny                          -- ,-   '\45'  -> cAny .|. cSymbol              -- --   '\46'  -> cAny .|. cSymbol              -- .-   '\47'  -> cAny .|. cSymbol              --  /-   '\48'  -> cAny .|. cIdent  .|. cDigit   -- 0-   '\49'  -> cAny .|. cIdent  .|. cDigit   -- 1-   '\50'  -> cAny .|. cIdent  .|. cDigit   -- 2-   '\51'  -> cAny .|. cIdent  .|. cDigit   -- 3-   '\52'  -> cAny .|. cIdent  .|. cDigit   -- 4-   '\53'  -> cAny .|. cIdent  .|. cDigit   -- 5-   '\54'  -> cAny .|. cIdent  .|. cDigit   -- 6-   '\55'  -> cAny .|. cIdent  .|. cDigit   -- 7-   '\56'  -> cAny .|. cIdent  .|. cDigit   -- 8-   '\57'  -> cAny .|. cIdent  .|. cDigit   -- 9-   '\58'  -> cAny .|. cSymbol              -- :-   '\59'  -> cAny                          -- ;-   '\60'  -> cAny .|. cSymbol              -- <-   '\61'  -> cAny .|. cSymbol              -- =-   '\62'  -> cAny .|. cSymbol              -- >-   '\63'  -> cAny .|. cSymbol              -- ?-   '\64'  -> cAny .|. cSymbol              -- @-   '\65'  -> cAny .|. cIdent  .|. cUpper   -- A-   '\66'  -> cAny .|. cIdent  .|. cUpper   -- B-   '\67'  -> cAny .|. cIdent  .|. cUpper   -- C-   '\68'  -> cAny .|. cIdent  .|. cUpper   -- D-   '\69'  -> cAny .|. cIdent  .|. cUpper   -- E-   '\70'  -> cAny .|. cIdent  .|. cUpper   -- F-   '\71'  -> cAny .|. cIdent  .|. cUpper   -- G-   '\72'  -> cAny .|. cIdent  .|. cUpper   -- H-   '\73'  -> cAny .|. cIdent  .|. cUpper   -- I-   '\74'  -> cAny .|. cIdent  .|. cUpper   -- J-   '\75'  -> cAny .|. cIdent  .|. cUpper   -- K-   '\76'  -> cAny .|. cIdent  .|. cUpper   -- L-   '\77'  -> cAny .|. cIdent  .|. cUpper   -- M-   '\78'  -> cAny .|. cIdent  .|. cUpper   -- N-   '\79'  -> cAny .|. cIdent  .|. cUpper   -- O-   '\80'  -> cAny .|. cIdent  .|. cUpper   -- P-   '\81'  -> cAny .|. cIdent  .|. cUpper   -- Q-   '\82'  -> cAny .|. cIdent  .|. cUpper   -- R-   '\83'  -> cAny .|. cIdent  .|. cUpper   -- S-   '\84'  -> cAny .|. cIdent  .|. cUpper   -- T-   '\85'  -> cAny .|. cIdent  .|. cUpper   -- U-   '\86'  -> cAny .|. cIdent  .|. cUpper   -- V-   '\87'  -> cAny .|. cIdent  .|. cUpper   -- W-   '\88'  -> cAny .|. cIdent  .|. cUpper   -- X-   '\89'  -> cAny .|. cIdent  .|. cUpper   -- Y-   '\90'  -> cAny .|. cIdent  .|. cUpper   -- Z-   '\91'  -> cAny                          -- [-   '\92'  -> cAny .|. cSymbol              -- backslash-   '\93'  -> cAny                          -- ]-   '\94'  -> cAny .|. cSymbol              --  ^-   '\95'  -> cAny .|. cIdent  .|. cLower   -- _-   '\96'  -> cAny                          -- `-   '\97'  -> cAny .|. cIdent  .|. cLower   -- a-   '\98'  -> cAny .|. cIdent  .|. cLower   -- b-   '\99'  -> cAny .|. cIdent  .|. cLower   -- c-   '\100' -> cAny .|. cIdent  .|. cLower   -- d-   '\101' -> cAny .|. cIdent  .|. cLower   -- e-   '\102' -> cAny .|. cIdent  .|. cLower   -- f-   '\103' -> cAny .|. cIdent  .|. cLower   -- g-   '\104' -> cAny .|. cIdent  .|. cLower   -- h-   '\105' -> cAny .|. cIdent  .|. cLower   -- i-   '\106' -> cAny .|. cIdent  .|. cLower   -- j-   '\107' -> cAny .|. cIdent  .|. cLower   -- k-   '\108' -> cAny .|. cIdent  .|. cLower   -- l-   '\109' -> cAny .|. cIdent  .|. cLower   -- m-   '\110' -> cAny .|. cIdent  .|. cLower   -- n-   '\111' -> cAny .|. cIdent  .|. cLower   -- o-   '\112' -> cAny .|. cIdent  .|. cLower   -- p-   '\113' -> cAny .|. cIdent  .|. cLower   -- q-   '\114' -> cAny .|. cIdent  .|. cLower   -- r-   '\115' -> cAny .|. cIdent  .|. cLower   -- s-   '\116' -> cAny .|. cIdent  .|. cLower   -- t-   '\117' -> cAny .|. cIdent  .|. cLower   -- u-   '\118' -> cAny .|. cIdent  .|. cLower   -- v-   '\119' -> cAny .|. cIdent  .|. cLower   -- w-   '\120' -> cAny .|. cIdent  .|. cLower   -- x-   '\121' -> cAny .|. cIdent  .|. cLower   -- y-   '\122' -> cAny .|. cIdent  .|. cLower   -- z-   '\123' -> cAny                          -- {-   '\124' -> cAny .|. cSymbol              --  |-   '\125' -> cAny                          -- }-   '\126' -> cAny .|. cSymbol              -- ~-   '\127' -> 0                             -- \177-   _ -> panic ("charType: " ++ show c)
− compiler/parser/HaddockUtils.hs 
@@ -1,35 +0,0 @@-{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}--module HaddockUtils where--import GhcPrelude--import GHC.Hs-import GHC.Types.SrcLoc--import Control.Monad---- -------------------------------------------------------------------------------- Adding documentation to record fields (used in parsing).--addFieldDoc :: LConDeclField a -> Maybe LHsDocString -> LConDeclField a-addFieldDoc (L l fld) doc-  = L l (fld { cd_fld_doc = cd_fld_doc fld `mplus` doc })--addFieldDocs :: [LConDeclField a] -> Maybe LHsDocString -> [LConDeclField a]-addFieldDocs [] _ = []-addFieldDocs (x:xs) doc = addFieldDoc x doc : xs---addConDoc :: LConDecl a -> Maybe LHsDocString -> LConDecl a-addConDoc decl    Nothing = decl-addConDoc (L p c) doc     = L p ( c { con_doc = con_doc c `mplus` doc } )--addConDocs :: [LConDecl a] -> Maybe LHsDocString -> [LConDecl a]-addConDocs [] _ = []-addConDocs [x] doc = [addConDoc x doc]-addConDocs (x:xs) doc = x : addConDocs xs doc--addConDocFirst :: [LConDecl a] -> Maybe LHsDocString -> [LConDecl a]-addConDocFirst [] _ = []-addConDocFirst (x:xs) doc = addConDoc x doc : xs
− compiler/parser/RdrHsSyn.hs 
@@ -1,3092 +0,0 @@------  (c) The University of Glasgow 2002-2006------- Functions over HsSyn specialised to RdrName.--{-# LANGUAGE CPP #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE MagicHash #-}-{-# LANGUAGE ViewPatterns #-}-{-# LANGUAGE GADTs #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE LambdaCase #-}-{-# LANGUAGE TypeApplications #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module   RdrHsSyn (-        mkHsOpApp,-        mkHsIntegral, mkHsFractional, mkHsIsString,-        mkHsDo, mkSpliceDecl,-        mkRoleAnnotDecl,-        mkClassDecl,-        mkTyData, mkDataFamInst,-        mkTySynonym, mkTyFamInstEqn,-        mkStandaloneKindSig,-        mkTyFamInst,-        mkFamDecl, mkLHsSigType,-        mkInlinePragma,-        mkPatSynMatchGroup,-        mkRecConstrOrUpdate, -- HsExp -> [HsFieldUpdate] -> P HsExp-        mkTyClD, mkInstD,-        mkRdrRecordCon, mkRdrRecordUpd,-        setRdrNameSpace,-        filterCTuple,--        cvBindGroup,-        cvBindsAndSigs,-        cvTopDecls,-        placeHolderPunRhs,--        -- Stuff to do with Foreign declarations-        mkImport,-        parseCImport,-        mkExport,-        mkExtName,    -- RdrName -> CLabelString-        mkGadtDecl,   -- [Located RdrName] -> LHsType RdrName -> ConDecl RdrName-        mkConDeclH98,--        -- Bunch of functions in the parser monad for-        -- checking and constructing values-        checkImportDecl,-        checkExpBlockArguments,-        checkPrecP,           -- Int -> P Int-        checkContext,         -- HsType -> P HsContext-        checkPattern,         -- HsExp -> P HsPat-        checkPattern_msg,-        checkMonadComp,       -- P (HsStmtContext GhcPs)-        checkValDef,          -- (SrcLoc, HsExp, HsRhs, [HsDecl]) -> P HsDecl-        checkValSigLhs,-        LRuleTyTmVar, RuleTyTmVar(..),-        mkRuleBndrs, mkRuleTyVarBndrs,-        checkRuleTyVarBndrNames,-        checkRecordSyntax,-        checkEmptyGADTs,-        addFatalError, hintBangPat,-        TyEl(..), mergeOps, mergeDataCon,-        mkBangTy,--        -- Help with processing exports-        ImpExpSubSpec(..),-        ImpExpQcSpec(..),-        mkModuleImpExp,-        mkTypeImpExp,-        mkImpExpSubSpec,-        checkImportSpec,--        -- Token symbols-        forallSym,-        starSym,--        -- Warnings and errors-        warnStarIsType,-        warnPrepositiveQualifiedModule,-        failOpFewArgs,-        failOpNotEnabledImportQualifiedPost,-        failOpImportQualifiedTwice,--        SumOrTuple (..),--        -- Expression/command/pattern ambiguity resolution-        PV,-        runPV,-        ECP(ECP, runECP_PV),-        runECP_P,-        DisambInfixOp(..),-        DisambECP(..),-        ecpFromExp,-        ecpFromCmd,-        PatBuilder,--    ) where--import GhcPrelude-import GHC.Hs           -- Lots of it-import GHC.Core.TyCon          ( TyCon, isTupleTyCon, tyConSingleDataCon_maybe )-import GHC.Core.DataCon        ( DataCon, dataConTyCon )-import GHC.Core.ConLike        ( ConLike(..) )-import GHC.Core.Coercion.Axiom ( Role, fsFromRole )-import GHC.Types.Name.Reader-import GHC.Types.Name-import GHC.Types.Basic-import Lexer-import GHC.Utils.Lexeme ( isLexCon )-import GHC.Core.Type    ( TyThing(..), funTyCon )-import TysWiredIn       ( cTupleTyConName, tupleTyCon, tupleDataCon,-                          nilDataConName, nilDataConKey,-                          listTyConName, listTyConKey, eqTyCon_RDR,-                          tupleTyConName, cTupleTyConNameArity_maybe )-import GHC.Types.ForeignCall-import PrelNames        ( allNameStrings )-import GHC.Types.SrcLoc-import GHC.Types.Unique ( hasKey )-import OrdList          ( OrdList, fromOL )-import Bag              ( emptyBag, consBag )-import Outputable-import FastString-import Maybes-import Util-import ApiAnnotation-import Data.List-import GHC.Driver.Session ( WarningFlag(..), DynFlags )-import ErrUtils ( Messages )--import Control.Monad-import Text.ParserCombinators.ReadP as ReadP-import Data.Char-import qualified Data.Monoid as Monoid-import Data.Data       ( dataTypeOf, fromConstr, dataTypeConstrs )-import Data.Kind       ( Type )--#include "HsVersions.h"---{- **********************************************************************--  Construction functions for Rdr stuff--  ********************************************************************* -}---- | mkClassDecl builds a RdrClassDecl, filling in the names for tycon and--- datacon by deriving them from the name of the class.  We fill in the names--- for the tycon and datacon corresponding to the class, by deriving them--- from the name of the class itself.  This saves recording the names in the--- interface file (which would be equally good).---- Similarly for mkConDecl, mkClassOpSig and default-method names.----         *** See Note [The Naming story] in GHC.Hs.Decls ****--mkTyClD :: LTyClDecl (GhcPass p) -> LHsDecl (GhcPass p)-mkTyClD (L loc d) = L loc (TyClD noExtField d)--mkInstD :: LInstDecl (GhcPass p) -> LHsDecl (GhcPass p)-mkInstD (L loc d) = L loc (InstD noExtField d)--mkClassDecl :: SrcSpan-            -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)-            -> Located (a,[LHsFunDep GhcPs])-            -> OrdList (LHsDecl GhcPs)-            -> P (LTyClDecl GhcPs)--mkClassDecl loc (L _ (mcxt, tycl_hdr)) fds where_cls-  = do { (binds, sigs, ats, at_defs, _, docs) <- cvBindsAndSigs where_cls-       ; let cxt = fromMaybe (noLoc []) mcxt-       ; (cls, tparams, fixity, ann) <- checkTyClHdr True tycl_hdr-       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan-       ; (tyvars,annst) <- checkTyVars (text "class") whereDots cls tparams-       ; addAnnsAt loc annst -- Add any API Annotations to the top SrcSpan-       ; return (L loc (ClassDecl { tcdCExt = noExtField, tcdCtxt = cxt-                                  , tcdLName = cls, tcdTyVars = tyvars-                                  , tcdFixity = fixity-                                  , tcdFDs = snd (unLoc fds)-                                  , tcdSigs = mkClassOpSigs sigs-                                  , tcdMeths = binds-                                  , tcdATs = ats, tcdATDefs = at_defs-                                  , tcdDocs  = docs })) }--mkTyData :: SrcSpan-         -> NewOrData-         -> Maybe (Located CType)-         -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)-         -> Maybe (LHsKind GhcPs)-         -> [LConDecl GhcPs]-         -> HsDeriving GhcPs-         -> P (LTyClDecl GhcPs)-mkTyData loc new_or_data cType (L _ (mcxt, tycl_hdr))-         ksig data_cons maybe_deriv-  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False tycl_hdr-       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan-       ; (tyvars, anns) <- checkTyVars (ppr new_or_data) equalsDots tc tparams-       ; addAnnsAt loc anns -- Add any API Annotations to the top SrcSpan-       ; defn <- mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv-       ; return (L loc (DataDecl { tcdDExt = noExtField,-                                   tcdLName = tc, tcdTyVars = tyvars,-                                   tcdFixity = fixity,-                                   tcdDataDefn = defn })) }--mkDataDefn :: NewOrData-           -> Maybe (Located CType)-           -> Maybe (LHsContext GhcPs)-           -> Maybe (LHsKind GhcPs)-           -> [LConDecl GhcPs]-           -> HsDeriving GhcPs-           -> P (HsDataDefn GhcPs)-mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv-  = do { checkDatatypeContext mcxt-       ; let cxt = fromMaybe (noLoc []) mcxt-       ; return (HsDataDefn { dd_ext = noExtField-                            , dd_ND = new_or_data, dd_cType = cType-                            , dd_ctxt = cxt-                            , dd_cons = data_cons-                            , dd_kindSig = ksig-                            , dd_derivs = maybe_deriv }) }---mkTySynonym :: SrcSpan-            -> LHsType GhcPs  -- LHS-            -> LHsType GhcPs  -- RHS-            -> P (LTyClDecl GhcPs)-mkTySynonym loc lhs rhs-  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs-       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan-       ; (tyvars, anns) <- checkTyVars (text "type") equalsDots tc tparams-       ; addAnnsAt loc anns -- Add any API Annotations to the top SrcSpan-       ; return (L loc (SynDecl { tcdSExt = noExtField-                                , tcdLName = tc, tcdTyVars = tyvars-                                , tcdFixity = fixity-                                , tcdRhs = rhs })) }--mkStandaloneKindSig-  :: SrcSpan-  -> Located [Located RdrName] -- LHS-  -> LHsKind GhcPs             -- RHS-  -> P (LStandaloneKindSig GhcPs)-mkStandaloneKindSig loc lhs rhs =-  do { vs <- mapM check_lhs_name (unLoc lhs)-     ; v <- check_singular_lhs (reverse vs)-     ; return $ L loc $ StandaloneKindSig noExtField v (mkLHsSigType rhs) }-  where-    check_lhs_name v@(unLoc->name) =-      if isUnqual name && isTcOcc (rdrNameOcc name)-      then return v-      else addFatalError (getLoc v) $-           hang (text "Expected an unqualified type constructor:") 2 (ppr v)-    check_singular_lhs vs =-      case vs of-        [] -> panic "mkStandaloneKindSig: empty left-hand side"-        [v] -> return v-        _ -> addFatalError (getLoc lhs) $-             vcat [ hang (text "Standalone kind signatures do not support multiple names at the moment:")-                       2 (pprWithCommas ppr vs)-                  , text "See https://gitlab.haskell.org/ghc/ghc/issues/16754 for details." ]--mkTyFamInstEqn :: Maybe [LHsTyVarBndr GhcPs]-               -> LHsType GhcPs-               -> LHsType GhcPs-               -> P (TyFamInstEqn GhcPs,[AddAnn])-mkTyFamInstEqn bndrs lhs rhs-  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs-       ; return (mkHsImplicitBndrs-                  (FamEqn { feqn_ext    = noExtField-                          , feqn_tycon  = tc-                          , feqn_bndrs  = bndrs-                          , feqn_pats   = tparams-                          , feqn_fixity = fixity-                          , feqn_rhs    = rhs }),-                 ann) }--mkDataFamInst :: SrcSpan-              -> NewOrData-              -> Maybe (Located CType)-              -> (Maybe ( LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs]-                        , LHsType GhcPs)-              -> Maybe (LHsKind GhcPs)-              -> [LConDecl GhcPs]-              -> HsDeriving GhcPs-              -> P (LInstDecl GhcPs)-mkDataFamInst loc new_or_data cType (mcxt, bndrs, tycl_hdr)-              ksig data_cons maybe_deriv-  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False tycl_hdr-       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan-       ; defn <- mkDataDefn new_or_data cType mcxt ksig data_cons maybe_deriv-       ; return (L loc (DataFamInstD noExtField (DataFamInstDecl (mkHsImplicitBndrs-                  (FamEqn { feqn_ext    = noExtField-                          , feqn_tycon  = tc-                          , feqn_bndrs  = bndrs-                          , feqn_pats   = tparams-                          , feqn_fixity = fixity-                          , feqn_rhs    = defn }))))) }--mkTyFamInst :: SrcSpan-            -> TyFamInstEqn GhcPs-            -> P (LInstDecl GhcPs)-mkTyFamInst loc eqn-  = return (L loc (TyFamInstD noExtField (TyFamInstDecl eqn)))--mkFamDecl :: SrcSpan-          -> FamilyInfo GhcPs-          -> LHsType GhcPs                   -- LHS-          -> Located (FamilyResultSig GhcPs) -- Optional result signature-          -> Maybe (LInjectivityAnn GhcPs)   -- Injectivity annotation-          -> P (LTyClDecl GhcPs)-mkFamDecl loc info lhs ksig injAnn-  = do { (tc, tparams, fixity, ann) <- checkTyClHdr False lhs-       ; addAnnsAt loc ann -- Add any API Annotations to the top SrcSpan-       ; (tyvars, anns) <- checkTyVars (ppr info) equals_or_where tc tparams-       ; addAnnsAt loc anns -- Add any API Annotations to the top SrcSpan-       ; return (L loc (FamDecl noExtField (FamilyDecl-                                           { fdExt       = noExtField-                                           , fdInfo      = info, fdLName = tc-                                           , fdTyVars    = tyvars-                                           , fdFixity    = fixity-                                           , fdResultSig = ksig-                                           , fdInjectivityAnn = injAnn }))) }-  where-    equals_or_where = case info of-                        DataFamily          -> empty-                        OpenTypeFamily      -> empty-                        ClosedTypeFamily {} -> whereDots--mkSpliceDecl :: LHsExpr GhcPs -> HsDecl GhcPs--- If the user wrote---      [pads| ... ]   then return a QuasiQuoteD---      $(e)           then return a SpliceD--- but if she wrote, say,---      f x            then behave as if she'd written $(f x)---                     ie a SpliceD------ Typed splices are not allowed at the top level, thus we do not represent them--- as spliced declaration.  See #10945-mkSpliceDecl lexpr@(L loc expr)-  | HsSpliceE _ splice@(HsUntypedSplice {}) <- expr-  = SpliceD noExtField (SpliceDecl noExtField (L loc splice) ExplicitSplice)--  | HsSpliceE _ splice@(HsQuasiQuote {}) <- expr-  = SpliceD noExtField (SpliceDecl noExtField (L loc splice) ExplicitSplice)--  | otherwise-  = SpliceD noExtField (SpliceDecl noExtField (L loc (mkUntypedSplice BareSplice lexpr))-                              ImplicitSplice)--mkRoleAnnotDecl :: SrcSpan-                -> Located RdrName                -- type being annotated-                -> [Located (Maybe FastString)]      -- roles-                -> P (LRoleAnnotDecl GhcPs)-mkRoleAnnotDecl loc tycon roles-  = do { roles' <- mapM parse_role roles-       ; return $ L loc $ RoleAnnotDecl noExtField tycon roles' }-  where-    role_data_type = dataTypeOf (undefined :: Role)-    all_roles = map fromConstr $ dataTypeConstrs role_data_type-    possible_roles = [(fsFromRole role, role) | role <- all_roles]--    parse_role (L loc_role Nothing) = return $ L loc_role Nothing-    parse_role (L loc_role (Just role))-      = case lookup role possible_roles of-          Just found_role -> return $ L loc_role $ Just found_role-          Nothing         ->-            let nearby = fuzzyLookup (unpackFS role)-                  (mapFst unpackFS possible_roles)-            in-            addFatalError loc_role-              (text "Illegal role name" <+> quotes (ppr role) $$-               suggestions nearby)--    suggestions []   = empty-    suggestions [r]  = text "Perhaps you meant" <+> quotes (ppr r)-      -- will this last case ever happen??-    suggestions list = hang (text "Perhaps you meant one of these:")-                       2 (pprWithCommas (quotes . ppr) list)--{- **********************************************************************--  #cvBinds-etc# Converting to @HsBinds@, etc.--  ********************************************************************* -}---- | Function definitions are restructured here. Each is assumed to be recursive--- initially, and non recursive definitions are discovered by the dependency--- analyser.-----  | Groups together bindings for a single function-cvTopDecls :: OrdList (LHsDecl GhcPs) -> [LHsDecl GhcPs]-cvTopDecls decls = go (fromOL decls)-  where-    go :: [LHsDecl GhcPs] -> [LHsDecl GhcPs]-    go []                     = []-    go ((L l (ValD x b)) : ds)-      = L l' (ValD x b') : go ds'-        where (L l' b', ds') = getMonoBind (L l b) ds-    go (d : ds)                    = d : go ds---- Declaration list may only contain value bindings and signatures.-cvBindGroup :: OrdList (LHsDecl GhcPs) -> P (HsValBinds GhcPs)-cvBindGroup binding-  = do { (mbs, sigs, fam_ds, tfam_insts-         , dfam_insts, _) <- cvBindsAndSigs binding-       ; ASSERT( null fam_ds && null tfam_insts && null dfam_insts)-         return $ ValBinds noExtField mbs sigs }--cvBindsAndSigs :: OrdList (LHsDecl GhcPs)-  -> P (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs]-          , [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl])--- Input decls contain just value bindings and signatures--- and in case of class or instance declarations also--- associated type declarations. They might also contain Haddock comments.-cvBindsAndSigs fb = go (fromOL fb)-  where-    go []              = return (emptyBag, [], [], [], [], [])-    go ((L l (ValD _ b)) : ds)-      = do { (bs, ss, ts, tfis, dfis, docs) <- go ds'-           ; return (b' `consBag` bs, ss, ts, tfis, dfis, docs) }-      where-        (b', ds') = getMonoBind (L l b) ds-    go ((L l decl) : ds)-      = do { (bs, ss, ts, tfis, dfis, docs) <- go ds-           ; case decl of-               SigD _ s-                 -> return (bs, L l s : ss, ts, tfis, dfis, docs)-               TyClD _ (FamDecl _ t)-                 -> return (bs, ss, L l t : ts, tfis, dfis, docs)-               InstD _ (TyFamInstD { tfid_inst = tfi })-                 -> return (bs, ss, ts, L l tfi : tfis, dfis, docs)-               InstD _ (DataFamInstD { dfid_inst = dfi })-                 -> return (bs, ss, ts, tfis, L l dfi : dfis, docs)-               DocD _ d-                 -> return (bs, ss, ts, tfis, dfis, L l d : docs)-               SpliceD _ d-                 -> addFatalError l $-                    hang (text "Declaration splices are allowed only" <+>-                          text "at the top level:")-                       2 (ppr d)-               _ -> pprPanic "cvBindsAndSigs" (ppr decl) }---------------------------------------------------------------------------------- Group function bindings into equation groups--getMonoBind :: LHsBind GhcPs -> [LHsDecl GhcPs]-  -> (LHsBind GhcPs, [LHsDecl GhcPs])--- Suppose      (b',ds') = getMonoBind b ds---      ds is a list of parsed bindings---      b is a MonoBinds that has just been read off the front---- Then b' is the result of grouping more equations from ds that--- belong with b into a single MonoBinds, and ds' is the depleted--- list of parsed bindings.------ All Haddock comments between equations inside the group are--- discarded.------ No AndMonoBinds or EmptyMonoBinds here; just single equations--getMonoBind (L loc1 (FunBind { fun_id = fun_id1@(L _ f1)-                             , fun_matches =-                               MG { mg_alts = (L _ mtchs1) } }))-            binds-  | has_args mtchs1-  = go mtchs1 loc1 binds []-  where-    go mtchs loc-       ((L loc2 (ValD _ (FunBind { fun_id = (L _ f2)-                                 , fun_matches =-                                    MG { mg_alts = (L _ mtchs2) } })))-         : binds) _-        | f1 == f2 = go (mtchs2 ++ mtchs)-                        (combineSrcSpans loc loc2) binds []-    go mtchs loc (doc_decl@(L loc2 (DocD {})) : binds) doc_decls-        = let doc_decls' = doc_decl : doc_decls-          in go mtchs (combineSrcSpans loc loc2) binds doc_decls'-    go mtchs loc binds doc_decls-        = ( L loc (makeFunBind fun_id1 (reverse mtchs))-          , (reverse doc_decls) ++ binds)-        -- Reverse the final matches, to get it back in the right order-        -- Do the same thing with the trailing doc comments--getMonoBind bind binds = (bind, binds)--has_args :: [LMatch GhcPs (LHsExpr GhcPs)] -> Bool-has_args []                                  = panic "RdrHsSyn:has_args"-has_args (L _ (Match { m_pats = args }) : _) = not (null args)-        -- Don't group together FunBinds if they have-        -- no arguments.  This is necessary now that variable bindings-        -- with no arguments are now treated as FunBinds rather-        -- than pattern bindings (tests/rename/should_fail/rnfail002).-has_args (L _ (XMatch nec) : _) = noExtCon nec--{- **********************************************************************--  #PrefixToHS-utils# Utilities for conversion--  ********************************************************************* -}--{- Note [Parsing data constructors is hard]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--The problem with parsing data constructors is that they look a lot like types.-Compare:--  (s1)   data T = C t1 t2-  (s2)   type T = C t1 t2--Syntactically, there's little difference between these declarations, except in-(s1) 'C' is a data constructor, but in (s2) 'C' is a type constructor.--This similarity would pose no problem if we knew ahead of time if we are-parsing a type or a constructor declaration. Looking at (s1) and (s2), a simple-(but wrong!) rule comes to mind: in 'data' declarations assume we are parsing-data constructors, and in other contexts (e.g. 'type' declarations) assume we-are parsing type constructors.--This simple rule does not work because of two problematic cases:--  (p1)   data T = C t1 t2 :+ t3-  (p2)   data T = C t1 t2 => t3--In (p1) we encounter (:+) and it turns out we are parsing an infix data-declaration, so (C t1 t2) is a type and 'C' is a type constructor.-In (p2) we encounter (=>) and it turns out we are parsing an existential-context, so (C t1 t2) is a constraint and 'C' is a type constructor.--As the result, in order to determine whether (C t1 t2) declares a data-constructor, a type, or a context, we would need unlimited lookahead which-'happy' is not so happy with.--To further complicate matters, the interpretation of (!) and (~) is different-in constructors and types:--  (b1)   type T = C ! D-  (b2)   data T = C ! D-  (b3)   data T = C ! D => E--In (b1) and (b3), (!) is a type operator with two arguments: 'C' and 'D'. At-the same time, in (b2) it is a strictness annotation: 'C' is a data constructor-with a single strict argument 'D'. For the programmer, these cases are usually-easy to tell apart due to whitespace conventions:--  (b2)   data T = C !D         -- no space after the bang hints that-                               -- it is a strictness annotation--For the parser, on the other hand, this whitespace does not matter. We cannot-tell apart (b2) from (b3) until we encounter (=>), so it requires unlimited-lookahead.--The solution that accounts for all of these issues is to initially parse data-declarations and types as a reversed list of TyEl:--  data TyEl = TyElOpr RdrName-            | TyElOpd (HsType GhcPs)-            | ...--For example, both occurrences of (C ! D) in the following example are parsed-into equal lists of TyEl:--  data T = C ! D => C ! D   results in   [ TyElOpd (HsTyVar "D")-                                         , TyElOpr "!"-                                         , TyElOpd (HsTyVar "C") ]--Note that elements are in reverse order. Also, 'C' is parsed as a type-constructor (HsTyVar) even when it is a data constructor. We fix this in-`tyConToDataCon`.--By the time the list of TyEl is assembled, we have looked ahead enough to-decide whether to reduce using `mergeOps` (for types) or `mergeDataCon` (for-data constructors). These functions are where the actual job of parsing is-done.---}---- | Reinterpret a type constructor, including type operators, as a data---   constructor.--- See Note [Parsing data constructors is hard]-tyConToDataCon :: SrcSpan -> RdrName -> Either (SrcSpan, SDoc) (Located RdrName)-tyConToDataCon loc tc-  | isTcOcc occ || isDataOcc occ-  , isLexCon (occNameFS occ)-  = return (L loc (setRdrNameSpace tc srcDataName))--  | otherwise-  = Left (loc, msg)-  where-    occ = rdrNameOcc tc-    msg = text "Not a data constructor:" <+> quotes (ppr tc)--mkPatSynMatchGroup :: Located RdrName-                   -> Located (OrdList (LHsDecl GhcPs))-                   -> P (MatchGroup GhcPs (LHsExpr GhcPs))-mkPatSynMatchGroup (L loc patsyn_name) (L _ decls) =-    do { matches <- mapM fromDecl (fromOL decls)-       ; when (null matches) (wrongNumberErr loc)-       ; return $ mkMatchGroup FromSource matches }-  where-    fromDecl (L loc decl@(ValD _ (PatBind _-                         pat@(L _ (ConPatIn ln@(L _ name) details))-                               rhs _))) =-        do { unless (name == patsyn_name) $-               wrongNameBindingErr loc decl-           ; match <- case details of-               PrefixCon pats -> return $ Match { m_ext = noExtField-                                                , m_ctxt = ctxt, m_pats = pats-                                                , m_grhss = rhs }-                   where-                     ctxt = FunRhs { mc_fun = ln-                                   , mc_fixity = Prefix-                                   , mc_strictness = NoSrcStrict }--               InfixCon p1 p2 -> return $ Match { m_ext = noExtField-                                                , m_ctxt = ctxt-                                                , m_pats = [p1, p2]-                                                , m_grhss = rhs }-                   where-                     ctxt = FunRhs { mc_fun = ln-                                   , mc_fixity = Infix-                                   , mc_strictness = NoSrcStrict }--               RecCon{} -> recordPatSynErr loc pat-           ; return $ L loc match }-    fromDecl (L loc decl) = extraDeclErr loc decl--    extraDeclErr loc decl =-        addFatalError loc $-        text "pattern synonym 'where' clause must contain a single binding:" $$-        ppr decl--    wrongNameBindingErr loc decl =-      addFatalError loc $-      text "pattern synonym 'where' clause must bind the pattern synonym's name"-      <+> quotes (ppr patsyn_name) $$ ppr decl--    wrongNumberErr loc =-      addFatalError loc $-      text "pattern synonym 'where' clause cannot be empty" $$-      text "In the pattern synonym declaration for: " <+> ppr (patsyn_name)--recordPatSynErr :: SrcSpan -> LPat GhcPs -> P a-recordPatSynErr loc pat =-    addFatalError loc $-    text "record syntax not supported for pattern synonym declarations:" $$-    ppr pat--mkConDeclH98 :: Located RdrName -> Maybe [LHsTyVarBndr GhcPs]-                -> Maybe (LHsContext GhcPs) -> HsConDeclDetails GhcPs-                -> ConDecl GhcPs--mkConDeclH98 name mb_forall mb_cxt args-  = ConDeclH98 { con_ext    = noExtField-               , con_name   = name-               , con_forall = noLoc $ isJust mb_forall-               , con_ex_tvs = mb_forall `orElse` []-               , con_mb_cxt = mb_cxt-               , con_args   = args-               , con_doc    = Nothing }--mkGadtDecl :: [Located RdrName]-           -> LHsType GhcPs     -- Always a HsForAllTy-           -> (ConDecl GhcPs, [AddAnn])-mkGadtDecl names ty-  = (ConDeclGADT { con_g_ext  = noExtField-                 , con_names  = names-                 , con_forall = L l $ isLHsForAllTy ty'-                 , con_qvars  = mkHsQTvs tvs-                 , con_mb_cxt = mcxt-                 , con_args   = args-                 , con_res_ty = res_ty-                 , con_doc    = Nothing }-    , anns1 ++ anns2)-  where-    (ty'@(L l _),anns1) = peel_parens ty []-    (tvs, rho) = splitLHsForAllTyInvis ty'-    (mcxt, tau, anns2) = split_rho rho []--    split_rho (L _ (HsQualTy { hst_ctxt = cxt, hst_body = tau })) ann-      = (Just cxt, tau, ann)-    split_rho (L l (HsParTy _ ty)) ann-      = split_rho ty (ann++mkParensApiAnn l)-    split_rho tau                  ann-      = (Nothing, tau, ann)--    (args, res_ty) = split_tau tau--    -- See Note [GADT abstract syntax] in GHC.Hs.Decls-    split_tau (L _ (HsFunTy _ (L loc (HsRecTy _ rf)) res_ty))-      = (RecCon (L loc rf), res_ty)-    split_tau tau-      = (PrefixCon [], tau)--    peel_parens (L l (HsParTy _ ty)) ann = peel_parens ty-                                                       (ann++mkParensApiAnn l)-    peel_parens ty                   ann = (ty, ann)---setRdrNameSpace :: RdrName -> NameSpace -> RdrName--- ^ This rather gruesome function is used mainly by the parser.--- When parsing:------ > data T a = T | T1 Int------ we parse the data constructors as /types/ because of parser ambiguities,--- so then we need to change the /type constr/ to a /data constr/------ The exact-name case /can/ occur when parsing:------ > data [] a = [] | a : [a]------ For the exact-name case we return an original name.-setRdrNameSpace (Unqual occ) ns = Unqual (setOccNameSpace ns occ)-setRdrNameSpace (Qual m occ) ns = Qual m (setOccNameSpace ns occ)-setRdrNameSpace (Orig m occ) ns = Orig m (setOccNameSpace ns occ)-setRdrNameSpace (Exact n)    ns-  | Just thing <- wiredInNameTyThing_maybe n-  = setWiredInNameSpace thing ns-    -- Preserve Exact Names for wired-in things,-    -- notably tuples and lists--  | isExternalName n-  = Orig (nameModule n) occ--  | otherwise   -- This can happen when quoting and then-                -- splicing a fixity declaration for a type-  = Exact (mkSystemNameAt (nameUnique n) occ (nameSrcSpan n))-  where-    occ = setOccNameSpace ns (nameOccName n)--setWiredInNameSpace :: TyThing -> NameSpace -> RdrName-setWiredInNameSpace (ATyCon tc) ns-  | isDataConNameSpace ns-  = ty_con_data_con tc-  | isTcClsNameSpace ns-  = Exact (getName tc)      -- No-op--setWiredInNameSpace (AConLike (RealDataCon dc)) ns-  | isTcClsNameSpace ns-  = data_con_ty_con dc-  | isDataConNameSpace ns-  = Exact (getName dc)      -- No-op--setWiredInNameSpace thing ns-  = pprPanic "setWiredinNameSpace" (pprNameSpace ns <+> ppr thing)--ty_con_data_con :: TyCon -> RdrName-ty_con_data_con tc-  | isTupleTyCon tc-  , Just dc <- tyConSingleDataCon_maybe tc-  = Exact (getName dc)--  | tc `hasKey` listTyConKey-  = Exact nilDataConName--  | otherwise  -- See Note [setRdrNameSpace for wired-in names]-  = Unqual (setOccNameSpace srcDataName (getOccName tc))--data_con_ty_con :: DataCon -> RdrName-data_con_ty_con dc-  | let tc = dataConTyCon dc-  , isTupleTyCon tc-  = Exact (getName tc)--  | dc `hasKey` nilDataConKey-  = Exact listTyConName--  | otherwise  -- See Note [setRdrNameSpace for wired-in names]-  = Unqual (setOccNameSpace tcClsName (getOccName dc))---- | Replaces constraint tuple names with corresponding boxed ones.-filterCTuple :: RdrName -> RdrName-filterCTuple (Exact n)-  | Just arity <- cTupleTyConNameArity_maybe n-  = Exact $ tupleTyConName BoxedTuple arity-filterCTuple rdr = rdr---{- Note [setRdrNameSpace for wired-in names]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In GHC.Types, which declares (:), we have-  infixr 5 :-The ambiguity about which ":" is meant is resolved by parsing it as a-data constructor, but then using dataTcOccs to try the type constructor too;-and that in turn calls setRdrNameSpace to change the name-space of ":" to-tcClsName.  There isn't a corresponding ":" type constructor, but it's painful-to make setRdrNameSpace partial, so we just make an Unqual name instead. It-really doesn't matter!--}--eitherToP :: Either (SrcSpan, SDoc) a -> P a--- Adapts the Either monad to the P monad-eitherToP (Left (loc, doc)) = addFatalError loc doc-eitherToP (Right thing)     = return thing--checkTyVars :: SDoc -> SDoc -> Located RdrName -> [LHsTypeArg GhcPs]-            -> P ( LHsQTyVars GhcPs  -- the synthesized type variables-                 , [AddAnn] )        -- action which adds annotations--- ^ Check whether the given list of type parameters are all type variables--- (possibly with a kind signature).-checkTyVars pp_what equals_or_where tc tparms-  = do { (tvs, anns) <- fmap unzip $ mapM check tparms-       ; return (mkHsQTvs tvs, concat anns) }-  where-    check (HsTypeArg _ ki@(L loc _))-                              = addFatalError loc $-                                      vcat [ text "Unexpected type application" <+>-                                            text "@" <> ppr ki-                                          , text "In the" <+> pp_what <+>-                                            ptext (sLit "declaration for") <+> quotes (ppr tc)]-    check (HsValArg ty) = chkParens [] ty-    check (HsArgPar sp) = addFatalError sp $-                          vcat [text "Malformed" <+> pp_what-                            <+> text "declaration for" <+> quotes (ppr tc)]-        -- Keep around an action for adjusting the annotations of extra parens-    chkParens :: [AddAnn] -> LHsType GhcPs-              -> P (LHsTyVarBndr GhcPs, [AddAnn])-    chkParens acc (L l (HsParTy _ ty)) = chkParens (mkParensApiAnn l ++ acc) ty-    chkParens acc ty = do-      tv <- chk ty-      return (tv, reverse acc)--        -- Check that the name space is correct!-    chk :: LHsType GhcPs -> P (LHsTyVarBndr GhcPs)-    chk (L l (HsKindSig _ (L lv (HsTyVar _ _ (L _ tv))) k))-        | isRdrTyVar tv    = return (L l (KindedTyVar noExtField (L lv tv) k))-    chk (L l (HsTyVar _ _ (L ltv tv)))-        | isRdrTyVar tv    = return (L l (UserTyVar noExtField (L ltv tv)))-    chk t@(L loc _)-        = addFatalError loc $-                vcat [ text "Unexpected type" <+> quotes (ppr t)-                     , text "In the" <+> pp_what-                       <+> ptext (sLit "declaration for") <+> quotes tc'-                     , vcat[ (text "A" <+> pp_what-                              <+> ptext (sLit "declaration should have form"))-                     , nest 2-                       (pp_what-                        <+> tc'-                        <+> hsep (map text (takeList tparms allNameStrings))-                        <+> equals_or_where) ] ]--    -- Avoid printing a constraint tuple in the error message. Print-    -- a plain old tuple instead (since that's what the user probably-    -- wrote). See #14907-    tc' = ppr $ fmap filterCTuple tc----whereDots, equalsDots :: SDoc--- Second argument to checkTyVars-whereDots  = text "where ..."-equalsDots = text "= ..."--checkDatatypeContext :: Maybe (LHsContext GhcPs) -> P ()-checkDatatypeContext Nothing = return ()-checkDatatypeContext (Just c)-    = do allowed <- getBit DatatypeContextsBit-         unless allowed $-             addError (getLoc c)-                 (text "Illegal datatype context (use DatatypeContexts):"-                  <+> pprLHsContext c)--type LRuleTyTmVar = Located RuleTyTmVar-data RuleTyTmVar = RuleTyTmVar (Located RdrName) (Maybe (LHsType GhcPs))--- ^ Essentially a wrapper for a @RuleBndr GhcPs@---- turns RuleTyTmVars into RuleBnrs - this is straightforward-mkRuleBndrs :: [LRuleTyTmVar] -> [LRuleBndr GhcPs]-mkRuleBndrs = fmap (fmap cvt_one)-  where cvt_one (RuleTyTmVar v Nothing)    = RuleBndr    noExtField v-        cvt_one (RuleTyTmVar v (Just sig)) =-          RuleBndrSig noExtField v (mkLHsSigWcType sig)---- turns RuleTyTmVars into HsTyVarBndrs - this is more interesting-mkRuleTyVarBndrs :: [LRuleTyTmVar] -> [LHsTyVarBndr GhcPs]-mkRuleTyVarBndrs = fmap (fmap cvt_one)-  where cvt_one (RuleTyTmVar v Nothing)    = UserTyVar   noExtField (fmap tm_to_ty v)-        cvt_one (RuleTyTmVar v (Just sig))-          = KindedTyVar noExtField (fmap tm_to_ty v) sig-    -- takes something in namespace 'varName' to something in namespace 'tvName'-        tm_to_ty (Unqual occ) = Unqual (setOccNameSpace tvName occ)-        tm_to_ty _ = panic "mkRuleTyVarBndrs"---- See note [Parsing explicit foralls in Rules] in Parser.y-checkRuleTyVarBndrNames :: [LHsTyVarBndr GhcPs] -> P ()-checkRuleTyVarBndrNames = mapM_ (check . fmap hsTyVarName)-  where check (L loc (Unqual occ)) = do-          when ((occNameString occ ==) `any` ["forall","family","role"])-               (addFatalError loc (text $ "parse error on input "-                                    ++ occNameString occ))-        check _ = panic "checkRuleTyVarBndrNames"--checkRecordSyntax :: (MonadP m, Outputable a) => Located a -> m (Located a)-checkRecordSyntax lr@(L loc r)-    = do allowed <- getBit TraditionalRecordSyntaxBit-         unless allowed $ addError loc $-           text "Illegal record syntax (use TraditionalRecordSyntax):" <+> ppr r-         return lr---- | Check if the gadt_constrlist is empty. Only raise parse error for--- `data T where` to avoid affecting existing error message, see #8258.-checkEmptyGADTs :: Located ([AddAnn], [LConDecl GhcPs])-                -> P (Located ([AddAnn], [LConDecl GhcPs]))-checkEmptyGADTs gadts@(L span (_, []))           -- Empty GADT declaration.-    = do gadtSyntax <- getBit GadtSyntaxBit   -- GADTs implies GADTSyntax-         unless gadtSyntax $ addError span $ vcat-           [ text "Illegal keyword 'where' in data declaration"-           , text "Perhaps you intended to use GADTs or a similar language"-           , text "extension to enable syntax: data T where"-           ]-         return gadts-checkEmptyGADTs gadts = return gadts              -- Ordinary GADT declaration.--checkTyClHdr :: Bool               -- True  <=> class header-                                   -- False <=> type header-             -> LHsType GhcPs-             -> P (Located RdrName,      -- the head symbol (type or class name)-                   [LHsTypeArg GhcPs],      -- parameters of head symbol-                   LexicalFixity,        -- the declaration is in infix format-                   [AddAnn]) -- API Annotation for HsParTy when stripping parens--- Well-formedness check and decomposition of type and class heads.--- Decomposes   T ty1 .. tyn   into    (T, [ty1, ..., tyn])---              Int :*: Bool   into    (:*:, [Int, Bool])--- returning the pieces-checkTyClHdr is_cls ty-  = goL ty [] [] Prefix-  where-    goL (L l ty) acc ann fix = go l ty acc ann fix--    -- workaround to define '*' despite StarIsType-    go lp (HsParTy _ (L l (HsStarTy _ isUni))) acc ann fix-      = do { warnStarBndr l-           ; let name = mkOccName tcClsName (starSym isUni)-           ; return (L l (Unqual name), acc, fix, (ann ++ mkParensApiAnn lp)) }--    go _ (HsTyVar _ _ ltc@(L _ tc)) acc ann fix-      | isRdrTc tc               = return (ltc, acc, fix, ann)-    go _ (HsOpTy _ t1 ltc@(L _ tc) t2) acc ann _fix-      | isRdrTc tc               = return (ltc, HsValArg t1:HsValArg t2:acc, Infix, ann)-    go l (HsParTy _ ty)    acc ann fix = goL ty acc (ann ++mkParensApiAnn l) fix-    go _ (HsAppTy _ t1 t2) acc ann fix = goL t1 (HsValArg t2:acc) ann fix-    go _ (HsAppKindTy l ty ki) acc ann fix = goL ty (HsTypeArg l ki:acc) ann fix-    go l (HsTupleTy _ HsBoxedOrConstraintTuple ts) [] ann fix-      = return (L l (nameRdrName tup_name), map HsValArg ts, fix, ann)-      where-        arity = length ts-        tup_name | is_cls    = cTupleTyConName arity-                 | otherwise = getName (tupleTyCon Boxed arity)-          -- See Note [Unit tuples] in GHC.Hs.Types  (TODO: is this still relevant?)-    go l _ _ _ _-      = addFatalError l (text "Malformed head of type or class declaration:"-                          <+> ppr ty)---- | Yield a parse error if we have a function applied directly to a do block--- etc. and BlockArguments is not enabled.-checkExpBlockArguments :: LHsExpr GhcPs -> PV ()-checkCmdBlockArguments :: LHsCmd GhcPs -> PV ()-(checkExpBlockArguments, checkCmdBlockArguments) = (checkExpr, checkCmd)-  where-    checkExpr :: LHsExpr GhcPs -> PV ()-    checkExpr expr = case unLoc expr of-      HsDo _ DoExpr _ -> check "do block" expr-      HsDo _ MDoExpr _ -> check "mdo block" expr-      HsLam {} -> check "lambda expression" expr-      HsCase {} -> check "case expression" expr-      HsLamCase {} -> check "lambda-case expression" expr-      HsLet {} -> check "let expression" expr-      HsIf {} -> check "if expression" expr-      HsProc {} -> check "proc expression" expr-      _ -> return ()--    checkCmd :: LHsCmd GhcPs -> PV ()-    checkCmd cmd = case unLoc cmd of-      HsCmdLam {} -> check "lambda command" cmd-      HsCmdCase {} -> check "case command" cmd-      HsCmdIf {} -> check "if command" cmd-      HsCmdLet {} -> check "let command" cmd-      HsCmdDo {} -> check "do command" cmd-      _ -> return ()--    check :: Outputable a => String -> Located a -> PV ()-    check element a = do-      blockArguments <- getBit BlockArgumentsBit-      unless blockArguments $-        addError (getLoc a) $-          text "Unexpected " <> text element <> text " in function application:"-           $$ nest 4 (ppr a)-           $$ text "You could write it with parentheses"-           $$ text "Or perhaps you meant to enable BlockArguments?"---- | Validate the context constraints and break up a context into a list--- of predicates.------ @---     (Eq a, Ord b)        -->  [Eq a, Ord b]---     Eq a                 -->  [Eq a]---     (Eq a)               -->  [Eq a]---     (((Eq a)))           -->  [Eq a]--- @-checkContext :: LHsType GhcPs -> P ([AddAnn],LHsContext GhcPs)-checkContext (L l orig_t)-  = check [] (L l orig_t)- where-  check anns (L lp (HsTupleTy _ HsBoxedOrConstraintTuple ts))-    -- (Eq a, Ord b) shows up as a tuple type. Only boxed tuples can-    -- be used as context constraints.-    = return (anns ++ mkParensApiAnn lp,L l ts)                -- Ditto ()--  check anns (L lp1 (HsParTy _ ty))-                                  -- to be sure HsParTy doesn't get into the way-       = check anns' ty-         where anns' = if l == lp1 then anns-                                   else (anns ++ mkParensApiAnn lp1)--  -- no need for anns, returning original-  check _anns t = checkNoDocs msg t *> return ([],L l [L l orig_t])--  msg = text "data constructor context"---- | Check recursively if there are any 'HsDocTy's in the given type.--- This only works on a subset of types produced by 'btype_no_ops'-checkNoDocs :: SDoc -> LHsType GhcPs -> P ()-checkNoDocs msg ty = go ty-  where-    go (L _ (HsAppKindTy _ ty ki)) = go ty *> go ki-    go (L _ (HsAppTy _ t1 t2)) = go t1 *> go t2-    go (L l (HsDocTy _ t ds)) = addError l $ hsep-                                  [ text "Unexpected haddock", quotes (ppr ds)-                                  , text "on", msg, quotes (ppr t) ]-    go _ = pure ()--checkImportDecl :: Maybe (Located Token)-                -> Maybe (Located Token)-                -> P ()-checkImportDecl mPre mPost = do-  let whenJust mg f = maybe (pure ()) f mg--  importQualifiedPostEnabled <- getBit ImportQualifiedPostBit--  -- Error if 'qualified' found in postpositive position and-  -- 'ImportQualifiedPost' is not in effect.-  whenJust mPost $ \post ->-    when (not importQualifiedPostEnabled) $-      failOpNotEnabledImportQualifiedPost (getLoc post)--  -- Error if 'qualified' occurs in both pre and postpositive-  -- positions.-  whenJust mPost $ \post ->-    when (isJust mPre) $-      failOpImportQualifiedTwice (getLoc post)--  -- Warn if 'qualified' found in prepositive position and-  -- 'Opt_WarnPrepositiveQualifiedModule' is enabled.-  whenJust mPre $ \pre ->-    warnPrepositiveQualifiedModule (getLoc pre)---- ---------------------------------------------------------------------------- Checking Patterns.---- We parse patterns as expressions and check for valid patterns below,--- converting the expression into a pattern at the same time.--checkPattern :: Located (PatBuilder GhcPs) -> P (LPat GhcPs)-checkPattern = runPV . checkLPat--checkPattern_msg :: SDoc -> PV (Located (PatBuilder GhcPs)) -> P (LPat GhcPs)-checkPattern_msg msg pp = runPV_msg msg (pp >>= checkLPat)--checkLPat :: Located (PatBuilder GhcPs) -> PV (LPat GhcPs)-checkLPat e@(L l _) = checkPat l e []--checkPat :: SrcSpan -> Located (PatBuilder GhcPs) -> [LPat GhcPs]-         -> PV (LPat GhcPs)-checkPat loc (L l e@(PatBuilderVar (L _ c))) args-  | isRdrDataCon c = return (L loc (ConPatIn (L l c) (PrefixCon args)))-  | not (null args) && patIsRec c =-      localPV_msg (\_ -> text "Perhaps you intended to use RecursiveDo") $-      patFail l (ppr e)-checkPat loc (L _ (PatBuilderApp f e)) args-  = do p <- checkLPat e-       checkPat loc f (p : args)-checkPat loc (L _ e) []-  = do p <- checkAPat loc e-       return (L loc p)-checkPat loc e _-  = patFail loc (ppr e)--checkAPat :: SrcSpan -> PatBuilder GhcPs -> PV (Pat GhcPs)-checkAPat loc e0 = do- nPlusKPatterns <- getBit NPlusKPatternsBit- case e0 of-   PatBuilderPat p -> return p-   PatBuilderVar x -> return (VarPat noExtField x)--   -- Overloaded numeric patterns (e.g. f 0 x = x)-   -- Negation is recorded separately, so that the literal is zero or +ve-   -- NB. Negative *primitive* literals are already handled by the lexer-   PatBuilderOverLit pos_lit -> return (mkNPat (L loc pos_lit) Nothing)--   -- n+k patterns-   PatBuilderOpApp-           (L nloc (PatBuilderVar (L _ n)))-           (L _ plus)-           (L lloc (PatBuilderOverLit lit@(OverLit {ol_val = HsIntegral {}})))-                      | nPlusKPatterns && (plus == plus_RDR)-                      -> return (mkNPlusKPat (L nloc n) (L lloc lit))--   PatBuilderOpApp l (L cl c) r-     | isRdrDataCon c -> do-         l <- checkLPat l-         r <- checkLPat r-         return (ConPatIn (L cl c) (InfixCon l r))--   PatBuilderPar e    -> checkLPat e >>= (return . (ParPat noExtField))-   _           -> patFail loc (ppr e0)--placeHolderPunRhs :: DisambECP b => PV (Located b)--- The RHS of a punned record field will be filled in by the renamer--- It's better not to make it an error, in case we want to print it when--- debugging-placeHolderPunRhs = mkHsVarPV (noLoc pun_RDR)--plus_RDR, pun_RDR :: RdrName-plus_RDR = mkUnqual varName (fsLit "+") -- Hack-pun_RDR  = mkUnqual varName (fsLit "pun-right-hand-side")--checkPatField :: LHsRecField GhcPs (Located (PatBuilder GhcPs))-              -> PV (LHsRecField GhcPs (LPat GhcPs))-checkPatField (L l fld) = do p <- checkLPat (hsRecFieldArg fld)-                             return (L l (fld { hsRecFieldArg = p }))--patFail :: SrcSpan -> SDoc -> PV a-patFail loc e = addFatalError loc $ text "Parse error in pattern:" <+> ppr e--patIsRec :: RdrName -> Bool-patIsRec e = e == mkUnqual varName (fsLit "rec")-------------------------------------------------------------------------------- Check Equation Syntax--checkValDef :: Located (PatBuilder GhcPs)-            -> Maybe (LHsType GhcPs)-            -> Located (a,GRHSs GhcPs (LHsExpr GhcPs))-            -> P ([AddAnn],HsBind GhcPs)--checkValDef lhs (Just sig) grhss-        -- x :: ty = rhs  parses as a *pattern* binding-  = do lhs' <- runPV $ mkHsTySigPV (combineLocs lhs sig) lhs sig >>= checkLPat-       checkPatBind lhs' grhss--checkValDef lhs Nothing g@(L l (_,grhss))-  = do  { mb_fun <- isFunLhs lhs-        ; case mb_fun of-            Just (fun, is_infix, pats, ann) ->-              checkFunBind NoSrcStrict ann (getLoc lhs)-                           fun is_infix pats (L l grhss)-            Nothing -> do-              lhs' <- checkPattern lhs-              checkPatBind lhs' g }--checkFunBind :: SrcStrictness-             -> [AddAnn]-             -> SrcSpan-             -> Located RdrName-             -> LexicalFixity-             -> [Located (PatBuilder GhcPs)]-             -> Located (GRHSs GhcPs (LHsExpr GhcPs))-             -> P ([AddAnn],HsBind GhcPs)-checkFunBind strictness ann lhs_loc fun is_infix pats (L rhs_span grhss)-  = do  ps <- mapM checkPattern pats-        let match_span = combineSrcSpans lhs_loc rhs_span-        -- Add back the annotations stripped from any HsPar values in the lhs-        -- mapM_ (\a -> a match_span) ann-        return (ann, makeFunBind fun-                  [L match_span (Match { m_ext = noExtField-                                       , m_ctxt = FunRhs-                                           { mc_fun    = fun-                                           , mc_fixity = is_infix-                                           , mc_strictness = strictness }-                                       , m_pats = ps-                                       , m_grhss = grhss })])-        -- The span of the match covers the entire equation.-        -- That isn't quite right, but it'll do for now.--makeFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)]-            -> HsBind GhcPs--- Like GHC.Hs.Utils.mkFunBind, but we need to be able to set the fixity too-makeFunBind fn ms-  = FunBind { fun_ext = noExtField,-              fun_id = fn,-              fun_matches = mkMatchGroup FromSource ms,-              fun_tick = [] }---- See Note [FunBind vs PatBind]-checkPatBind :: LPat GhcPs-             -> Located (a,GRHSs GhcPs (LHsExpr GhcPs))-             -> P ([AddAnn],HsBind GhcPs)-checkPatBind lhs (L match_span (_,grhss))-    | BangPat _ p <- unLoc lhs-    , VarPat _ v <- unLoc p-    = return ([], makeFunBind v [L match_span (m v)])-  where-    m v = Match { m_ext = noExtField-                , m_ctxt = FunRhs { mc_fun    = L (getLoc lhs) (unLoc v)-                                  , mc_fixity = Prefix-                                  , mc_strictness = SrcStrict }-                , m_pats = []-                , m_grhss = grhss }--checkPatBind lhs (L _ (_,grhss))-  = return ([],PatBind noExtField lhs grhss ([],[]))--checkValSigLhs :: LHsExpr GhcPs -> P (Located RdrName)-checkValSigLhs (L _ (HsVar _ lrdr@(L _ v)))-  | isUnqual v-  , not (isDataOcc (rdrNameOcc v))-  = return lrdr--checkValSigLhs lhs@(L l _)-  = addFatalError l ((text "Invalid type signature:" <+>-                       ppr lhs <+> text ":: ...")-                      $$ text hint)-  where-    hint | foreign_RDR `looks_like` lhs-         = "Perhaps you meant to use ForeignFunctionInterface?"-         | default_RDR `looks_like` lhs-         = "Perhaps you meant to use DefaultSignatures?"-         | pattern_RDR `looks_like` lhs-         = "Perhaps you meant to use PatternSynonyms?"-         | otherwise-         = "Should be of form <variable> :: <type>"--    -- A common error is to forget the ForeignFunctionInterface flag-    -- so check for that, and suggest.  cf #3805-    -- Sadly 'foreign import' still barfs 'parse error' because-    --  'import' is a keyword-    looks_like s (L _ (HsVar _ (L _ v))) = v == s-    looks_like s (L _ (HsApp _ lhs _))   = looks_like s lhs-    looks_like _ _                       = False--    foreign_RDR = mkUnqual varName (fsLit "foreign")-    default_RDR = mkUnqual varName (fsLit "default")-    pattern_RDR = mkUnqual varName (fsLit "pattern")--checkDoAndIfThenElse-  :: (Outputable a, Outputable b, Outputable c)-  => Located a -> Bool -> b -> Bool -> Located c -> PV ()-checkDoAndIfThenElse guardExpr semiThen thenExpr semiElse elseExpr- | semiThen || semiElse-    = do doAndIfThenElse <- getBit DoAndIfThenElseBit-         unless doAndIfThenElse $ do-             addError (combineLocs guardExpr elseExpr)-                            (text "Unexpected semi-colons in conditional:"-                          $$ nest 4 expr-                          $$ text "Perhaps you meant to use DoAndIfThenElse?")- | otherwise            = return ()-    where pprOptSemi True  = semi-          pprOptSemi False = empty-          expr = text "if"   <+> ppr guardExpr <> pprOptSemi semiThen <+>-                 text "then" <+> ppr thenExpr  <> pprOptSemi semiElse <+>-                 text "else" <+> ppr elseExpr--isFunLhs :: Located (PatBuilder GhcPs)-      -> P (Maybe (Located RdrName, LexicalFixity, [Located (PatBuilder GhcPs)],[AddAnn]))--- A variable binding is parsed as a FunBind.--- Just (fun, is_infix, arg_pats) if e is a function LHS-isFunLhs e = go e [] []- where-   go (L loc (PatBuilderVar (L _ f))) es ann-       | not (isRdrDataCon f)        = return (Just (L loc f, Prefix, es, ann))-   go (L _ (PatBuilderApp f e)) es       ann = go f (e:es) ann-   go (L l (PatBuilderPar e))   es@(_:_) ann = go e es (ann ++ mkParensApiAnn l)-   go (L loc (PatBuilderOpApp l (L loc' op) r)) es ann-        | not (isRdrDataCon op)         -- We have found the function!-        = return (Just (L loc' op, Infix, (l:r:es), ann))-        | otherwise                     -- Infix data con; keep going-        = do { mb_l <- go l es ann-             ; case mb_l of-                 Just (op', Infix, j : k : es', ann')-                   -> return (Just (op', Infix, j : op_app : es', ann'))-                   where-                     op_app = L loc (PatBuilderOpApp k-                               (L loc' op) r)-                 _ -> return Nothing }-   go _ _ _ = return Nothing---- | Either an operator or an operand.-data TyEl = TyElOpr RdrName | TyElOpd (HsType GhcPs)-          | TyElKindApp SrcSpan (LHsType GhcPs)-          -- See Note [TyElKindApp SrcSpan interpretation]-          | TyElUnpackedness ([AddAnn], SourceText, SrcUnpackedness)-          | TyElDocPrev HsDocString---{- Note [TyElKindApp SrcSpan interpretation]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--A TyElKindApp captures type application written in haskell as--    @ Foo--where Foo is some type.--The SrcSpan reflects both elements, and there are AnnAt and AnnVal API-Annotations attached to this SrcSpan for the specific locations of-each within it.--}--instance Outputable TyEl where-  ppr (TyElOpr name) = ppr name-  ppr (TyElOpd ty) = ppr ty-  ppr (TyElKindApp _ ki) = text "@" <> ppr ki-  ppr (TyElUnpackedness (_, _, unpk)) = ppr unpk-  ppr (TyElDocPrev doc) = ppr doc---- | Extract a strictness/unpackedness annotation from the front of a reversed--- 'TyEl' list.-pUnpackedness-  :: [Located TyEl] -- reversed TyEl-  -> Maybe ( SrcSpan-           , [AddAnn]-           , SourceText-           , SrcUnpackedness-           , [Located TyEl] {- remaining TyEl -})-pUnpackedness (L l x1 : xs)-  | TyElUnpackedness (anns, prag, unpk) <- x1-  = Just (l, anns, prag, unpk, xs)-pUnpackedness _ = Nothing--pBangTy-  :: LHsType GhcPs  -- a type to be wrapped inside HsBangTy-  -> [Located TyEl] -- reversed TyEl-  -> ( Bool           {- has a strict mark been consumed? -}-     , LHsType GhcPs  {- the resulting BangTy -}-     , P ()           {- add annotations -}-     , [Located TyEl] {- remaining TyEl -})-pBangTy lt@(L l1 _) xs =-  case pUnpackedness xs of-    Nothing -> (False, lt, pure (), xs)-    Just (l2, anns, prag, unpk, xs') ->-      let bl = combineSrcSpans l1 l2-          bt = addUnpackedness (prag, unpk) lt-      in (True, L bl bt, addAnnsAt bl anns, xs')--mkBangTy :: SrcStrictness -> LHsType GhcPs -> HsType GhcPs-mkBangTy strictness =-  HsBangTy noExtField (HsSrcBang NoSourceText NoSrcUnpack strictness)--addUnpackedness :: (SourceText, SrcUnpackedness) -> LHsType GhcPs -> HsType GhcPs-addUnpackedness (prag, unpk) (L _ (HsBangTy x bang t))-  | HsSrcBang NoSourceText NoSrcUnpack strictness <- bang-  = HsBangTy x (HsSrcBang prag unpk strictness) t-addUnpackedness (prag, unpk) t-  = HsBangTy noExtField (HsSrcBang prag unpk NoSrcStrict) t---- | Merge a /reversed/ and /non-empty/ soup of operators and operands---   into a type.------ User input: @F x y + G a b * X@--- Input to 'mergeOps': [X, *, b, a, G, +, y, x, F]--- Output corresponds to what the user wrote assuming all operators are of the--- same fixity and right-associative.------ It's a bit silly that we're doing it at all, as the renamer will have to--- rearrange this, and it'd be easier to keep things separate.------ See Note [Parsing data constructors is hard]-mergeOps :: [Located TyEl] -> P (LHsType GhcPs)-mergeOps ((L l1 (TyElOpd t)) : xs)-  | (_, t', addAnns, xs') <- pBangTy (L l1 t) xs-  , null xs' -- We accept a BangTy only when there are no preceding TyEl.-  = addAnns >> return t'-mergeOps all_xs = go (0 :: Int) [] id all_xs-  where-    -- NB. When modifying clauses in 'go', make sure that the reasoning in-    -- Note [Non-empty 'acc' in mergeOps clause [end]] is still correct.--    -- clause [unpk]:-    -- handle (NO)UNPACK pragmas-    go k acc ops_acc ((L l (TyElUnpackedness (anns, unpkSrc, unpk))):xs) =-      if not (null acc) && null xs-      then do { acc' <- eitherToP $ mergeOpsAcc acc-              ; let a = ops_acc acc'-                    strictMark = HsSrcBang unpkSrc unpk NoSrcStrict-                    bl = combineSrcSpans l (getLoc a)-                    bt = HsBangTy noExtField strictMark a-              ; addAnnsAt bl anns-              ; return (L bl bt) }-      else addFatalError l unpkError-      where-        unpkSDoc = case unpkSrc of-          NoSourceText -> ppr unpk-          SourceText str -> text str <> text " #-}"-        unpkError-          | not (null xs) = unpkSDoc <+> text "cannot appear inside a type."-          | null acc && k == 0 = unpkSDoc <+> text "must be applied to a type."-          | otherwise =-              -- See Note [Impossible case in mergeOps clause [unpk]]-              panic "mergeOps.UNPACK: impossible position"--    -- clause [doc]:-    -- we do not expect to encounter any docs-    go _ _ _ ((L l (TyElDocPrev _)):_) =-      failOpDocPrev l--    -- clause [opr]:-    -- when we encounter an operator, we must have accumulated-    -- something for its rhs, and there must be something left-    -- to build its lhs.-    go k acc ops_acc ((L l (TyElOpr op)):xs) =-      if null acc || null (filter isTyElOpd xs)-        then failOpFewArgs (L l op)-        else do { acc' <- eitherToP (mergeOpsAcc acc)-                ; go (k + 1) [] (\c -> mkLHsOpTy c (L l op) (ops_acc acc')) xs }-      where-        isTyElOpd (L _ (TyElOpd _)) = True-        isTyElOpd _ = False--    -- clause [opd]:-    -- whenever an operand is encountered, it is added to the accumulator-    go k acc ops_acc ((L l (TyElOpd a)):xs) = go k (HsValArg (L l a):acc) ops_acc xs--    -- clause [tyapp]:-    -- whenever a type application is encountered, it is added to the accumulator-    go k acc ops_acc ((L _ (TyElKindApp l a)):xs) = go k (HsTypeArg l a:acc) ops_acc xs--    -- clause [end]-    -- See Note [Non-empty 'acc' in mergeOps clause [end]]-    go _ acc ops_acc [] = do { acc' <- eitherToP (mergeOpsAcc acc)-                             ; return (ops_acc acc') }--mergeOpsAcc :: [HsArg (LHsType GhcPs) (LHsKind GhcPs)]-         -> Either (SrcSpan, SDoc) (LHsType GhcPs)-mergeOpsAcc [] = panic "mergeOpsAcc: empty input"-mergeOpsAcc (HsTypeArg _ (L loc ki):_)-  = Left (loc, text "Unexpected type application:" <+> ppr ki)-mergeOpsAcc (HsValArg ty : xs) = go1 ty xs-  where-    go1 :: LHsType GhcPs-        -> [HsArg (LHsType GhcPs) (LHsKind GhcPs)]-        -> Either (SrcSpan, SDoc) (LHsType GhcPs)-    go1 lhs []     = Right lhs-    go1 lhs (x:xs) = case x of-        HsValArg ty -> go1 (mkHsAppTy lhs ty) xs-        HsTypeArg loc ki -> let ty = mkHsAppKindTy loc lhs ki-                            in go1 ty xs-        HsArgPar _ -> go1 lhs xs-mergeOpsAcc (HsArgPar _: xs) = mergeOpsAcc xs--{- Note [Impossible case in mergeOps clause [unpk]]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-This case should never occur. Let us consider all possible-variations of 'acc', 'xs', and 'k':--  acc          xs        k-==============================-  null   |    null       0      -- "must be applied to a type"-  null   |  not null     0      -- "must be applied to a type"-not null |    null       0      -- successful parse-not null |  not null     0      -- "cannot appear inside a type"-  null   |    null      >0      -- handled in clause [opr]-  null   |  not null    >0      -- "cannot appear inside a type"-not null |    null      >0      -- successful parse-not null |  not null    >0      -- "cannot appear inside a type"--The (null acc && null xs && k>0) case is handled in clause [opr]-by the following check:--    if ... || null (filter isTyElOpd xs)-     then failOpFewArgs (L l op)--We know that this check has been performed because k>0, and by-the time we reach the end of the list (null xs), the only way-for (null acc) to hold is that there was not a single TyElOpd-between the operator and the end of the list. But this case is-caught by the check and reported as 'failOpFewArgs'.--}--{- Note [Non-empty 'acc' in mergeOps clause [end]]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In clause [end] we need to know that 'acc' is non-empty to call 'mergeAcc'-without a check.--Running 'mergeOps' with an empty input list is forbidden, so we do not consider-this possibility. This means we'll hit at least one other clause before we-reach clause [end].--* Clauses [unpk] and [doc] do not call 'go' recursively, so we cannot hit-  clause [end] from there.-* Clause [opd] makes 'acc' non-empty, so if we hit clause [end] after it, 'acc'-  will be non-empty.-* Clause [opr] checks that (filter isTyElOpd xs) is not null - so we are going-  to hit clause [opd] at least once before we reach clause [end], making 'acc'-  non-empty.-* There are no other clauses.--Therefore, it is safe to omit a check for non-emptiness of 'acc' in clause-[end].---}--pInfixSide :: [Located TyEl] -> Maybe (LHsType GhcPs, P (), [Located TyEl])-pInfixSide ((L l (TyElOpd t)):xs)-  | (True, t', addAnns, xs') <- pBangTy (L l t) xs-  = Just (t', addAnns, xs')-pInfixSide (el:xs1)-  | Just t1 <- pLHsTypeArg el-  = go [t1] xs1-   where-     go :: [HsArg (LHsType GhcPs) (LHsKind GhcPs)]-        -> [Located TyEl] -> Maybe (LHsType GhcPs, P (), [Located TyEl])-     go acc (el:xs)-       | Just t <- pLHsTypeArg el-       = go (t:acc) xs-     go acc xs = case mergeOpsAcc acc of-       Left _ -> Nothing-       Right acc' -> Just (acc', pure (), xs)-pInfixSide _ = Nothing--pLHsTypeArg :: Located TyEl -> Maybe (HsArg (LHsType GhcPs) (LHsKind GhcPs))-pLHsTypeArg (L l (TyElOpd a)) = Just (HsValArg (L l a))-pLHsTypeArg (L _ (TyElKindApp l a)) = Just (HsTypeArg l a)-pLHsTypeArg _ = Nothing--pDocPrev :: [Located TyEl] -> (Maybe LHsDocString, [Located TyEl])-pDocPrev = go Nothing-  where-    go mTrailingDoc ((L l (TyElDocPrev doc)):xs) =-      go (mTrailingDoc `mplus` Just (L l doc)) xs-    go mTrailingDoc xs = (mTrailingDoc, xs)--orErr :: Maybe a -> b -> Either b a-orErr (Just a) _ = Right a-orErr Nothing b = Left b---- | Merge a /reversed/ and /non-empty/ soup of operators and operands---   into a data constructor.------ User input: @C !A B -- ^ doc@--- Input to 'mergeDataCon': ["doc", B, !A, C]--- Output: (C, PrefixCon [!A, B], "doc")------ See Note [Parsing data constructors is hard]-mergeDataCon-      :: [Located TyEl]-      -> P ( Located RdrName         -- constructor name-           , HsConDeclDetails GhcPs  -- constructor field information-           , Maybe LHsDocString      -- docstring to go on the constructor-           )-mergeDataCon all_xs =-  do { (addAnns, a) <- eitherToP res-     ; addAnns-     ; return a }-  where-    -- We start by splitting off the trailing documentation comment,-    -- if any exists.-    (mTrailingDoc, all_xs') = pDocPrev all_xs--    -- Determine whether the trailing documentation comment exists and is the-    -- only docstring in this constructor declaration.-    ---    -- When true, it means that it applies to the constructor itself:-    --    data T = C-    --             A-    --             B -- ^ Comment on C (singleDoc == True)-    ---    -- When false, it means that it applies to the last field:-    --    data T = C -- ^ Comment on C-    --             A -- ^ Comment on A-    --             B -- ^ Comment on B (singleDoc == False)-    singleDoc = isJust mTrailingDoc &&-                null [ () | (L _ (TyElDocPrev _)) <- all_xs' ]--    -- The result of merging the list of reversed TyEl into a-    -- data constructor, along with [AddAnn].-    res = goFirst all_xs'--    -- Take the trailing docstring into account when interpreting-    -- the docstring near the constructor.-    ---    --    data T = C -- ^ docstring right after C-    --             A-    --             B -- ^ trailing docstring-    ---    -- 'mkConDoc' must be applied to the docstring right after C, so that it-    -- falls back to the trailing docstring when appropriate (see singleDoc).-    mkConDoc mDoc | singleDoc = mDoc `mplus` mTrailingDoc-                  | otherwise = mDoc--    -- The docstring for the last field of a data constructor.-    trailingFieldDoc | singleDoc = Nothing-                     | otherwise = mTrailingDoc--    goFirst [ L l (TyElOpd (HsTyVar _ _ (L _ tc))) ]-      = do { data_con <- tyConToDataCon l tc-           ; return (pure (), (data_con, PrefixCon [], mTrailingDoc)) }-    goFirst ((L l (TyElOpd (HsRecTy _ fields))):xs)-      | (mConDoc, xs') <- pDocPrev xs-      , [ L l' (TyElOpd (HsTyVar _ _ (L _ tc))) ] <- xs'-      = do { data_con <- tyConToDataCon l' tc-           ; let mDoc = mTrailingDoc `mplus` mConDoc-           ; return (pure (), (data_con, RecCon (L l fields), mDoc)) }-    goFirst [L l (TyElOpd (HsTupleTy _ HsBoxedOrConstraintTuple ts))]-      = return ( pure ()-               , ( L l (getRdrName (tupleDataCon Boxed (length ts)))-                 , PrefixCon ts-                 , mTrailingDoc ) )-    goFirst ((L l (TyElOpd t)):xs)-      | (_, t', addAnns, xs') <- pBangTy (L l t) xs-      = go addAnns Nothing [mkLHsDocTyMaybe t' trailingFieldDoc] xs'-    goFirst (L l (TyElKindApp _ _):_)-      = goInfix Monoid.<> Left (l, kindAppErr)-    goFirst xs-      = go (pure ()) mTrailingDoc [] xs--    go addAnns mLastDoc ts [ L l (TyElOpd (HsTyVar _ _ (L _ tc))) ]-      = do { data_con <- tyConToDataCon l tc-           ; return (addAnns, (data_con, PrefixCon ts, mkConDoc mLastDoc)) }-    go addAnns mLastDoc ts ((L l (TyElDocPrev doc)):xs) =-      go addAnns (mLastDoc `mplus` Just (L l doc)) ts xs-    go addAnns mLastDoc ts ((L l (TyElOpd t)):xs)-      | (_, t', addAnns', xs') <- pBangTy (L l t) xs-      , t'' <- mkLHsDocTyMaybe t' mLastDoc-      = go (addAnns >> addAnns') Nothing (t'':ts) xs'-    go _ _ _ ((L _ (TyElOpr _)):_) =-      -- Encountered an operator: backtrack to the beginning and attempt-      -- to parse as an infix definition.-      goInfix-    go _ _ _ (L l (TyElKindApp _ _):_) =  goInfix Monoid.<> Left (l, kindAppErr)-    go _ _ _ _ = Left malformedErr-      where-        malformedErr =-          ( foldr combineSrcSpans noSrcSpan (map getLoc all_xs')-          , text "Cannot parse data constructor" <+>-            text "in a data/newtype declaration:" $$-            nest 2 (hsep . reverse $ map ppr all_xs'))--    goInfix =-      do { let xs0 = all_xs'-         ; (rhs_t, rhs_addAnns, xs1) <- pInfixSide xs0 `orErr` malformedErr-         ; let (mOpDoc, xs2) = pDocPrev xs1-         ; (op, xs3) <- case xs2 of-              (L l (TyElOpr op)) : xs3 ->-                do { data_con <- tyConToDataCon l op-                   ; return (data_con, xs3) }-              _ -> Left malformedErr-         ; let (mLhsDoc, xs4) = pDocPrev xs3-         ; (lhs_t, lhs_addAnns, xs5) <- pInfixSide xs4 `orErr` malformedErr-         ; unless (null xs5) (Left malformedErr)-         ; let rhs = mkLHsDocTyMaybe rhs_t trailingFieldDoc-               lhs = mkLHsDocTyMaybe lhs_t mLhsDoc-               addAnns = lhs_addAnns >> rhs_addAnns-         ; return (addAnns, (op, InfixCon lhs rhs, mkConDoc mOpDoc)) }-      where-        malformedErr =-          ( foldr combineSrcSpans noSrcSpan (map getLoc all_xs')-          , text "Cannot parse an infix data constructor" <+>-            text "in a data/newtype declaration:" $$-            nest 2 (hsep . reverse $ map ppr all_xs'))--    kindAppErr =-      text "Unexpected kind application" <+>-      text "in a data/newtype declaration:" $$-      nest 2 (hsep . reverse $ map ppr all_xs')-------------------------------------------------------------------------------- | Check for monad comprehensions------ If the flag MonadComprehensions is set, return a 'MonadComp' context,--- otherwise use the usual 'ListComp' context--checkMonadComp :: PV (HsStmtContext GhcRn)-checkMonadComp = do-    monadComprehensions <- getBit MonadComprehensionsBit-    return $ if monadComprehensions-                then MonadComp-                else ListComp---- ---------------------------------------------------------------------------- Expression/command/pattern ambiguity.--- See Note [Ambiguous syntactic categories]------- See Note [Parser-Validator]--- See Note [Ambiguous syntactic categories]------ This newtype is required to avoid impredicative types in monadic--- productions. That is, in a production that looks like------    | ... {% return (ECP ...) }------ we are dealing with---    P ECP--- whereas without a newtype we would be dealing with---    P (forall b. DisambECP b => PV (Located b))----newtype ECP =-  ECP { runECP_PV :: forall b. DisambECP b => PV (Located b) }--runECP_P :: DisambECP b => ECP -> P (Located b)-runECP_P p = runPV (runECP_PV p)--ecpFromExp :: LHsExpr GhcPs -> ECP-ecpFromExp a = ECP (ecpFromExp' a)--ecpFromCmd :: LHsCmd GhcPs -> ECP-ecpFromCmd a = ECP (ecpFromCmd' a)---- | Disambiguate infix operators.--- See Note [Ambiguous syntactic categories]-class DisambInfixOp b where-  mkHsVarOpPV :: Located RdrName -> PV (Located b)-  mkHsConOpPV :: Located RdrName -> PV (Located b)-  mkHsInfixHolePV :: SrcSpan -> PV (Located b)--instance DisambInfixOp (HsExpr GhcPs) where-  mkHsVarOpPV v = return $ L (getLoc v) (HsVar noExtField v)-  mkHsConOpPV v = return $ L (getLoc v) (HsVar noExtField v)-  mkHsInfixHolePV l = return $ L l hsHoleExpr--instance DisambInfixOp RdrName where-  mkHsConOpPV (L l v) = return $ L l v-  mkHsVarOpPV (L l v) = return $ L l v-  mkHsInfixHolePV l =-    addFatalError l $ text "Invalid infix hole, expected an infix operator"---- | Disambiguate constructs that may appear when we do not know ahead of time whether we are--- parsing an expression, a command, or a pattern.--- See Note [Ambiguous syntactic categories]-class b ~ (Body b) GhcPs => DisambECP b where-  -- | See Note [Body in DisambECP]-  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.-  ecpFromExp' :: LHsExpr GhcPs -> PV (Located b)-  -- | Disambiguate "\... -> ..." (lambda)-  mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located b) -> PV (Located b)-  -- | Disambiguate "let ... in ..."-  mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located b -> PV (Located b)-  -- | Infix operator representation-  type InfixOp b-  -- | Bring superclass constraints on InfixOp into scope.-  -- See Note [UndecidableSuperClasses for associated types]-  superInfixOp :: (DisambInfixOp (InfixOp b) => PV (Located b )) -> PV (Located b)-  -- | Disambiguate "f # x" (infix operator)-  mkHsOpAppPV :: SrcSpan -> Located b -> Located (InfixOp b) -> Located b -> PV (Located b)-  -- | Disambiguate "case ... of ..."-  mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located b) -> PV (Located b)-  -- | Function argument representation-  type FunArg b-  -- | Bring superclass constraints on FunArg into scope.-  -- See Note [UndecidableSuperClasses for associated types]-  superFunArg :: (DisambECP (FunArg b) => PV (Located b)) -> PV (Located b)-  -- | Disambiguate "f x" (function application)-  mkHsAppPV :: SrcSpan -> Located b -> Located (FunArg b) -> PV (Located b)-  -- | Disambiguate "if ... then ... else ..."-  mkHsIfPV :: SrcSpan-         -> LHsExpr GhcPs-         -> Bool  -- semicolon?-         -> Located b-         -> Bool  -- semicolon?-         -> Located b-         -> PV (Located b)-  -- | Disambiguate "do { ... }" (do notation)-  mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located b)] -> PV (Located b)-  -- | Disambiguate "( ... )" (parentheses)-  mkHsParPV :: SrcSpan -> Located b -> PV (Located b)-  -- | Disambiguate a variable "f" or a data constructor "MkF".-  mkHsVarPV :: Located RdrName -> PV (Located b)-  -- | Disambiguate a monomorphic literal-  mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located b)-  -- | Disambiguate an overloaded literal-  mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located b)-  -- | Disambiguate a wildcard-  mkHsWildCardPV :: SrcSpan -> PV (Located b)-  -- | Disambiguate "a :: t" (type annotation)-  mkHsTySigPV :: SrcSpan -> Located b -> LHsType GhcPs -> PV (Located b)-  -- | Disambiguate "[a,b,c]" (list syntax)-  mkHsExplicitListPV :: SrcSpan -> [Located b] -> PV (Located b)-  -- | Disambiguate "$(...)" and "[quasi|...|]" (TH splices)-  mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located b)-  -- | Disambiguate "f { a = b, ... }" syntax (record construction and record updates)-  mkHsRecordPV ::-    SrcSpan ->-    SrcSpan ->-    Located b ->-    ([LHsRecField GhcPs (Located b)], Maybe SrcSpan) ->-    PV (Located b)-  -- | Disambiguate "-a" (negation)-  mkHsNegAppPV :: SrcSpan -> Located b -> PV (Located b)-  -- | Disambiguate "(# a)" (right operator section)-  mkHsSectionR_PV :: SrcSpan -> Located (InfixOp b) -> Located b -> PV (Located b)-  -- | Disambiguate "(a -> b)" (view pattern)-  mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located b -> PV (Located b)-  -- | Disambiguate "a@b" (as-pattern)-  mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located b -> PV (Located b)-  -- | Disambiguate "~a" (lazy pattern)-  mkHsLazyPatPV :: SrcSpan -> Located b -> PV (Located b)-  -- | Disambiguate "!a" (bang pattern)-  mkHsBangPatPV :: SrcSpan -> Located b -> PV (Located b)-  -- | Disambiguate tuple sections and unboxed sums-  mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple b -> PV (Located b)-  -- | Validate infixexp LHS to reject unwanted {-# SCC ... #-} pragmas-  rejectPragmaPV :: Located b -> PV ()---{- Note [UndecidableSuperClasses for associated types]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-(This Note is about the code in GHC, not about the user code that we are parsing)--Assume we have a class C with an associated type T:--  class C a where-    type T a-    ...--If we want to add 'C (T a)' as a superclass, we need -XUndecidableSuperClasses:--  {-# LANGUAGE UndecidableSuperClasses #-}-  class C (T a) => C a where-    type T a-    ...--Unfortunately, -XUndecidableSuperClasses don't work all that well, sometimes-making GHC loop. The workaround is to bring this constraint into scope-manually with a helper method:--  class C a where-    type T a-    superT :: (C (T a) => r) -> r--In order to avoid ambiguous types, 'r' must mention 'a'.--For consistency, we use this approach for all constraints on associated types,-even when -XUndecidableSuperClasses are not required.--}--{- 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 :: Type ->-*). To satisfy this requirement, we say that (b ~ Body b GhcPs) in the-superclass constraints of DisambECP.--The alternative is to change mkBodyStmt, mkBindStmt, unguardedRHS, etc, to drop-this requirement. It is possible and would allow removing the type index of-PatBuilder, but leads to worse type inference, breaking some code in the-typechecker.--}--instance DisambECP (HsCmd GhcPs) where-  type Body (HsCmd GhcPs) = HsCmd-  ecpFromCmd' = return-  ecpFromExp' (L l e) = cmdFail l (ppr e)-  mkHsLamPV l mg = return $ L l (HsCmdLam noExtField mg)-  mkHsLetPV l bs e = return $ L l (HsCmdLet noExtField bs e)-  type InfixOp (HsCmd GhcPs) = HsExpr GhcPs-  superInfixOp m = m-  mkHsOpAppPV l c1 op c2 = do-    let cmdArg c = L (getLoc c) $ HsCmdTop noExtField c-    return $ L l $ HsCmdArrForm noExtField op Infix Nothing [cmdArg c1, cmdArg c2]-  mkHsCasePV l c mg = return $ L l (HsCmdCase noExtField c mg)-  type FunArg (HsCmd GhcPs) = HsExpr GhcPs-  superFunArg m = m-  mkHsAppPV l c e = do-    checkCmdBlockArguments c-    checkExpBlockArguments e-    return $ L l (HsCmdApp noExtField c e)-  mkHsIfPV l c semi1 a semi2 b = do-    checkDoAndIfThenElse c semi1 a semi2 b-    return $ L l (mkHsCmdIf c a b)-  mkHsDoPV l stmts = return $ L l (HsCmdDo noExtField stmts)-  mkHsParPV l c = return $ L l (HsCmdPar noExtField c)-  mkHsVarPV (L l v) = cmdFail l (ppr v)-  mkHsLitPV (L l a) = cmdFail l (ppr a)-  mkHsOverLitPV (L l a) = cmdFail l (ppr a)-  mkHsWildCardPV l = cmdFail l (text "_")-  mkHsTySigPV l a sig = cmdFail l (ppr a <+> text "::" <+> ppr sig)-  mkHsExplicitListPV l xs = cmdFail l $-    brackets (fsep (punctuate comma (map ppr xs)))-  mkHsSplicePV (L l sp) = cmdFail l (ppr sp)-  mkHsRecordPV l _ a (fbinds, ddLoc) = cmdFail l $-    ppr a <+> ppr (mk_rec_fields fbinds ddLoc)-  mkHsNegAppPV l a = cmdFail l (text "-" <> ppr a)-  mkHsSectionR_PV l op c = cmdFail l $-    let pp_op = fromMaybe (panic "cannot print infix operator")-                          (ppr_infix_expr (unLoc op))-    in pp_op <> ppr c-  mkHsViewPatPV l a b = cmdFail l $-    ppr a <+> text "->" <+> ppr b-  mkHsAsPatPV l v c = cmdFail l $-    pprPrefixOcc (unLoc v) <> text "@" <> ppr c-  mkHsLazyPatPV l c = cmdFail l $-    text "~" <> ppr c-  mkHsBangPatPV l c = cmdFail l $-    text "!" <> ppr c-  mkSumOrTuplePV l boxity a = cmdFail l (pprSumOrTuple boxity a)-  rejectPragmaPV _ = return ()--cmdFail :: SrcSpan -> SDoc -> PV a-cmdFail loc e = addFatalError loc $-  hang (text "Parse error in command:") 2 (ppr e)--instance DisambECP (HsExpr GhcPs) where-  type Body (HsExpr GhcPs) = HsExpr-  ecpFromCmd' (L l c) = do-    addError l $ vcat-      [ text "Arrow command found where an expression was expected:",-        nest 2 (ppr c) ]-    return (L l hsHoleExpr)-  ecpFromExp' = return-  mkHsLamPV l mg = return $ L l (HsLam noExtField mg)-  mkHsLetPV l bs c = return $ L l (HsLet noExtField bs c)-  type InfixOp (HsExpr GhcPs) = HsExpr GhcPs-  superInfixOp m = m-  mkHsOpAppPV l e1 op e2 = do-    return $ L l $ OpApp noExtField e1 op e2-  mkHsCasePV l e mg = return $ L l (HsCase noExtField e mg)-  type FunArg (HsExpr GhcPs) = HsExpr GhcPs-  superFunArg m = m-  mkHsAppPV l e1 e2 = do-    checkExpBlockArguments e1-    checkExpBlockArguments e2-    return $ L l (HsApp noExtField e1 e2)-  mkHsIfPV l c semi1 a semi2 b = do-    checkDoAndIfThenElse c semi1 a semi2 b-    return $ L l (mkHsIf c a b)-  mkHsDoPV l stmts = return $ L l (HsDo noExtField DoExpr stmts)-  mkHsParPV l e = return $ L l (HsPar noExtField e)-  mkHsVarPV v@(getLoc -> l) = return $ L l (HsVar noExtField v)-  mkHsLitPV (L l a) = return $ L l (HsLit noExtField a)-  mkHsOverLitPV (L l a) = return $ L l (HsOverLit noExtField a)-  mkHsWildCardPV l = return $ L l hsHoleExpr-  mkHsTySigPV l a sig = return $ L l (ExprWithTySig noExtField a (mkLHsSigWcType sig))-  mkHsExplicitListPV l xs = return $ L l (ExplicitList noExtField Nothing xs)-  mkHsSplicePV sp = return $ mapLoc (HsSpliceE noExtField) sp-  mkHsRecordPV l lrec a (fbinds, ddLoc) = do-    r <- mkRecConstrOrUpdate a lrec (fbinds, ddLoc)-    checkRecordSyntax (L l r)-  mkHsNegAppPV l a = return $ L l (NegApp noExtField a noSyntaxExpr)-  mkHsSectionR_PV l op e = return $ L l (SectionR noExtField op e)-  mkHsViewPatPV l a b = patSynErr "View pattern" l (ppr a <+> text "->" <+> ppr b) empty-  mkHsAsPatPV l v e =-    patSynErr "@-pattern" l (pprPrefixOcc (unLoc v) <> text "@" <> ppr e) $-    text "Type application syntax requires a space before '@'"-  mkHsLazyPatPV l e = patSynErr "Lazy pattern" l (text "~" <> ppr e) $-    text "Did you mean to add a space after the '~'?"-  mkHsBangPatPV l e = patSynErr "Bang pattern" l (text "!" <> ppr e) $-    text "Did you mean to add a space after the '!'?"-  mkSumOrTuplePV = mkSumOrTupleExpr-  rejectPragmaPV (L _ (OpApp _ _ _ e)) =-    -- assuming left-associative parsing of operators-    rejectPragmaPV e-  rejectPragmaPV (L l (HsPragE _ prag _)) =-    addError l $-      hang (text "A pragma is not allowed in this position:") 2 (ppr prag)-  rejectPragmaPV _ = return ()--patSynErr :: String -> SrcSpan -> SDoc -> SDoc -> PV (LHsExpr GhcPs)-patSynErr item l e explanation =-  do { addError l $-        sep [text item <+> text "in expression context:",-             nest 4 (ppr e)] $$-        explanation-     ; return (L l hsHoleExpr) }--hsHoleExpr :: HsExpr (GhcPass id)-hsHoleExpr = HsUnboundVar noExtField (mkVarOcc "_")---- | See Note [Ambiguous syntactic categories] and Note [PatBuilder]-data PatBuilder p-  = PatBuilderPat (Pat p)-  | PatBuilderPar (Located (PatBuilder p))-  | PatBuilderApp (Located (PatBuilder p)) (Located (PatBuilder p))-  | PatBuilderOpApp (Located (PatBuilder p)) (Located RdrName) (Located (PatBuilder p))-  | PatBuilderVar (Located RdrName)-  | PatBuilderOverLit (HsOverLit GhcPs)--instance Outputable (PatBuilder GhcPs) where-  ppr (PatBuilderPat p) = ppr p-  ppr (PatBuilderPar (L _ p)) = parens (ppr p)-  ppr (PatBuilderApp (L _ p1) (L _ p2)) = ppr p1 <+> ppr p2-  ppr (PatBuilderOpApp (L _ p1) op (L _ p2)) = ppr p1 <+> ppr op <+> ppr p2-  ppr (PatBuilderVar v) = ppr v-  ppr (PatBuilderOverLit l) = ppr l--instance DisambECP (PatBuilder GhcPs) where-  type Body (PatBuilder GhcPs) = PatBuilder-  ecpFromCmd' (L l c) =-    addFatalError l $-      text "Command syntax in pattern:" <+> ppr c-  ecpFromExp' (L l e) =-    addFatalError l $-      text "Expression syntax in pattern:" <+> ppr e-  mkHsLamPV l _ = addFatalError l $-    text "Lambda-syntax in pattern." $$-    text "Pattern matching on functions is not possible."-  mkHsLetPV l _ _ = addFatalError l $ text "(let ... in ...)-syntax in pattern"-  type InfixOp (PatBuilder GhcPs) = RdrName-  superInfixOp m = m-  mkHsOpAppPV l p1 op p2 = return $ L l $ PatBuilderOpApp p1 op p2-  mkHsCasePV l _ _ = addFatalError l $ text "(case ... of ...)-syntax in pattern"-  type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs-  superFunArg m = m-  mkHsAppPV l p1 p2 = return $ L l (PatBuilderApp p1 p2)-  mkHsIfPV l _ _ _ _ _ = addFatalError l $ text "(if ... then ... else ...)-syntax in pattern"-  mkHsDoPV l _ = addFatalError l $ text "do-notation in pattern"-  mkHsParPV l p = return $ L l (PatBuilderPar p)-  mkHsVarPV v@(getLoc -> l) = return $ L l (PatBuilderVar v)-  mkHsLitPV lit@(L l a) = do-    checkUnboxedStringLitPat lit-    return $ L l (PatBuilderPat (LitPat noExtField a))-  mkHsOverLitPV (L l a) = return $ L l (PatBuilderOverLit a)-  mkHsWildCardPV l = return $ L l (PatBuilderPat (WildPat noExtField))-  mkHsTySigPV l b sig = do-    p <- checkLPat b-    return $ L l (PatBuilderPat (SigPat noExtField p (mkLHsSigWcType sig)))-  mkHsExplicitListPV l xs = do-    ps <- traverse checkLPat xs-    return (L l (PatBuilderPat (ListPat noExtField ps)))-  mkHsSplicePV (L l sp) = return $ L l (PatBuilderPat (SplicePat noExtField sp))-  mkHsRecordPV l _ a (fbinds, ddLoc) = do-    r <- mkPatRec a (mk_rec_fields fbinds ddLoc)-    checkRecordSyntax (L l r)-  mkHsNegAppPV l (L lp p) = do-    lit <- case p of-      PatBuilderOverLit pos_lit -> return (L lp pos_lit)-      _ -> patFail l (text "-" <> ppr p)-    return $ L l (PatBuilderPat (mkNPat lit (Just noSyntaxExpr)))-  mkHsSectionR_PV l op p = patFail l (pprInfixOcc (unLoc op) <> ppr p)-  mkHsViewPatPV l a b = do-    p <- checkLPat b-    return $ L l (PatBuilderPat (ViewPat noExtField a p))-  mkHsAsPatPV l v e = do-    p <- checkLPat e-    return $ L l (PatBuilderPat (AsPat noExtField v p))-  mkHsLazyPatPV l e = do-    p <- checkLPat e-    return $ L l (PatBuilderPat (LazyPat noExtField p))-  mkHsBangPatPV l e = do-    p <- checkLPat e-    let pb = BangPat noExtField p-    hintBangPat l pb-    return $ L l (PatBuilderPat pb)-  mkSumOrTuplePV = mkSumOrTuplePat-  rejectPragmaPV _ = return ()--checkUnboxedStringLitPat :: Located (HsLit GhcPs) -> PV ()-checkUnboxedStringLitPat (L loc lit) =-  case lit of-    HsStringPrim _ _  -- Trac #13260-      -> addFatalError loc (text "Illegal unboxed string literal in pattern:" $$ ppr lit)-    _ -> return ()--mkPatRec ::-  Located (PatBuilder GhcPs) ->-  HsRecFields GhcPs (Located (PatBuilder GhcPs)) ->-  PV (PatBuilder GhcPs)-mkPatRec (unLoc -> PatBuilderVar c) (HsRecFields fs dd)-  | isRdrDataCon (unLoc c)-  = do fs <- mapM checkPatField fs-       return (PatBuilderPat (ConPatIn c (RecCon (HsRecFields fs dd))))-mkPatRec p _ =-  addFatalError (getLoc p) $ text "Not a record constructor:" <+> ppr p--{- Note [Ambiguous syntactic categories]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--There are places in the grammar where we do not know whether we are parsing an-expression or a pattern without unlimited lookahead (which we do not have in-'happy'):--View patterns:--    f (Con a b     ) = ...  -- 'Con a b' is a pattern-    f (Con a b -> x) = ...  -- 'Con a b' is an expression--do-notation:--    do { Con a b <- x } -- 'Con a b' is a pattern-    do { Con a b }      -- 'Con a b' is an expression--Guards:--    x | True <- p && q = ...  -- 'True' is a pattern-    x | True           = ...  -- 'True' is an expression--Top-level value/function declarations (FunBind/PatBind):--    f ! a         -- TH splice-    f ! a = ...   -- function declaration--    Until we encounter the = sign, we don't know if it's a top-level-    TemplateHaskell splice where ! is used, or if it's a function declaration-    where ! is bound.--There are also places in the grammar where we do not know whether we are-parsing an expression or a command:--    proc x -> do { (stuff) -< x }   -- 'stuff' is an expression-    proc x -> do { (stuff) }        -- 'stuff' is a command--    Until we encounter arrow syntax (-<) we don't know whether to parse 'stuff'-    as an expression or a command.--In fact, do-notation is subject to both ambiguities:--    proc x -> do { (stuff) -< x }        -- 'stuff' is an expression-    proc x -> do { (stuff) <- f -< x }   -- 'stuff' is a pattern-    proc x -> do { (stuff) }             -- 'stuff' is a command--There are many possible solutions to this problem. For an overview of the ones-we decided against, see Note [Resolving parsing ambiguities: non-taken alternatives]--The solution that keeps basic definitions (such as HsExpr) clean, keeps the-concerns local to the parser, and does not require duplication of hsSyn types,-or an extra pass over the entire AST, is to parse into an overloaded-parser-validator (a so-called tagless final encoding):--    class DisambECP b where ...-    instance DisambECP (HsCmd GhcPs) where ...-    instance DisambECP (HsExp GhcPs) where ...-    instance DisambECP (PatBuilder GhcPs) where ...--The 'DisambECP' class contains functions to build and validate 'b'. For example,-to add parentheses we have:--  mkHsParPV :: DisambECP b => SrcSpan -> Located b -> PV (Located b)--'mkHsParPV' will wrap the inner value in HsCmdPar for commands, HsPar for-expressions, and 'PatBuilderPar' for patterns (later transformed into ParPat,-see Note [PatBuilder]).--Consider the 'alts' production used to parse case-of alternatives:--  alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }-    : alts1     { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }-    | ';' alts  { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }--We abstract over LHsExpr GhcPs, and it becomes:--  alts :: { forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])) }-    : alts1     { $1 >>= \ $1 ->-                  return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }-    | ';' alts  { $2 >>= \ $2 ->-                  return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }--Compared to the initial definition, the added bits are:--    forall b. DisambECP b => PV ( ... ) -- in the type signature-    $1 >>= \ $1 -> return $             -- in one reduction rule-    $2 >>= \ $2 -> return $             -- in another reduction rule--The overhead is constant relative to the size of the rest of the reduction-rule, so this approach scales well to large parser productions.--Note that we write ($1 >>= \ $1 -> ...), so the second $1 is in a binding-position and shadows the previous $1. We can do this because internally-'happy' desugars $n to happy_var_n, and the rationale behind this idiom-is to be able to write (sLL $1 $>) later on. The alternative would be to-write this as ($1 >>= \ fresh_name -> ...), but then we couldn't refer-to the last fresh name as $>.--}---{- Note [Resolving parsing ambiguities: non-taken alternatives]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--Alternative I, extra constructors in GHC.Hs.Expr--------------------------------------------------We could add extra constructors to HsExpr to represent command-specific and-pattern-specific syntactic constructs. Under this scheme, we parse patterns-and commands as expressions and rejig later.  This is what GHC used to do, and-it polluted 'HsExpr' with irrelevant constructors:--  * for commands: 'HsArrForm', 'HsArrApp'-  * for patterns: 'EWildPat', 'EAsPat', 'EViewPat', 'ELazyPat'--(As of now, we still do that for patterns, but we plan to fix it).--There are several issues with this:--  * The implementation details of parsing are leaking into hsSyn definitions.--  * Code that uses HsExpr has to panic on these impossible-after-parsing cases.--  * HsExpr is arbitrarily selected as the extension basis. Why not extend-    HsCmd or HsPat with extra constructors instead?--Alternative II, extra constructors in GHC.Hs.Expr for GhcPs-------------------------------------------------------------We could address some of the problems with Alternative I by using Trees That-Grow and extending HsExpr only in the GhcPs pass. However, GhcPs corresponds to-the output of parsing, not to its intermediate results, so we wouldn't want-them there either.--Alternative III, extra constructors in GHC.Hs.Expr for GhcPrePs-----------------------------------------------------------------We could introduce a new pass, GhcPrePs, to keep GhcPs pristine.-Unfortunately, creating a new pass would significantly bloat conversion code-and slow down the compiler by adding another linear-time pass over the entire-AST. For example, in order to build HsExpr GhcPrePs, we would need to build-HsLocalBinds GhcPrePs (as part of HsLet), and we never want HsLocalBinds-GhcPrePs.---Alternative IV, sum type and bottom-up data flow--------------------------------------------------Expressions and commands are disjoint. There are no user inputs that could be-interpreted as either an expression or a command depending on outer context:--  5        -- definitely an expression-  x -< y   -- definitely a command--Even though we have both 'HsLam' and 'HsCmdLam', we can look at-the body to disambiguate:--  \p -> 5        -- definitely an expression-  \p -> x -< y   -- definitely a command--This means we could use a bottom-up flow of information to determine-whether we are parsing an expression or a command, using a sum type-for intermediate results:--  Either (LHsExpr GhcPs) (LHsCmd GhcPs)--There are two problems with this:--  * We cannot handle the ambiguity between expressions and-    patterns, which are not disjoint.--  * Bottom-up flow of information leads to poor error messages. Consider--        if ... then 5 else (x -< y)--    Do we report that '5' is not a valid command or that (x -< y) is not a-    valid expression?  It depends on whether we want the entire node to be-    'HsIf' or 'HsCmdIf', and this information flows top-down, from the-    surrounding parsing context (are we in 'proc'?)--Alternative V, backtracking with parser combinators-----------------------------------------------------One might think we could sidestep the issue entirely by using a backtracking-parser and doing something along the lines of (try pExpr <|> pPat).--Turns out, this wouldn't work very well, as there can be patterns inside-expressions (e.g. via 'case', 'let', 'do') and expressions inside patterns-(e.g. view patterns). To handle this, we would need to backtrack while-backtracking, and unbound levels of backtracking lead to very fragile-performance.--Alternative VI, an intermediate data type-------------------------------------------There are common syntactic elements of expressions, commands, and patterns-(e.g. all of them must have balanced parentheses), and we can capture this-common structure in an intermediate data type, Frame:--data Frame-  = FrameVar RdrName-    -- ^ Identifier: Just, map, BS.length-  | FrameTuple [LTupArgFrame] Boxity-    -- ^ Tuple (section): (a,b) (a,b,c) (a,,) (,a,)-  | FrameTySig LFrame (LHsSigWcType GhcPs)-    -- ^ Type signature: x :: ty-  | FramePar (SrcSpan, SrcSpan) LFrame-    -- ^ Parentheses-  | FrameIf LFrame LFrame LFrame-    -- ^ If-expression: if p then x else y-  | FrameCase LFrame [LFrameMatch]-    -- ^ Case-expression: case x of { p1 -> e1; p2 -> e2 }-  | FrameDo (HsStmtContext GhcRn) [LFrameStmt]-    -- ^ Do-expression: do { s1; a <- s2; s3 }-  ...-  | FrameExpr (HsExpr GhcPs)   -- unambiguously an expression-  | FramePat (HsPat GhcPs)     -- unambiguously a pattern-  | FrameCommand (HsCmd GhcPs) -- unambiguously a command--To determine which constructors 'Frame' needs to have, we take the union of-intersections between HsExpr, HsCmd, and HsPat.--The intersection between HsPat and HsExpr:--  HsPat  =  VarPat   | TuplePat      | SigPat        | ParPat   | ...-  HsExpr =  HsVar    | ExplicitTuple | ExprWithTySig | HsPar    | ...-  --------------------------------------------------------------------  Frame  =  FrameVar | FrameTuple    | FrameTySig    | FramePar | ...--The intersection between HsCmd and HsExpr:--  HsCmd  = HsCmdIf | HsCmdCase | HsCmdDo | HsCmdPar-  HsExpr = HsIf    | HsCase    | HsDo    | HsPar-  -------------------------------------------------  Frame = FrameIf  | FrameCase | FrameDo | FramePar--The intersection between HsCmd and HsPat:--  HsPat  = ParPat   | ...-  HsCmd  = HsCmdPar | ...-  ------------------------  Frame  = FramePar | ...--Take the union of each intersection and this yields the final 'Frame' data-type. The problem with this approach is that we end up duplicating a good-portion of hsSyn:--    Frame         for  HsExpr, HsPat, HsCmd-    TupArgFrame   for  HsTupArg-    FrameMatch    for  Match-    FrameStmt     for  StmtLR-    FrameGRHS     for  GRHS-    FrameGRHSs    for  GRHSs-    ...--Alternative VII, a product type---------------------------------We could avoid the intermediate representation of Alternative VI by parsing-into a product of interpretations directly:--    -- See Note [Parser-Validator]-    type ExpCmdPat = ( PV (LHsExpr GhcPs)-                     , PV (LHsCmd GhcPs)-                     , PV (LHsPat GhcPs) )--This means that in positions where we do not know whether to produce-expression, a pattern, or a command, we instead produce a parser-validator for-each possible option.--Then, as soon as we have parsed far enough to resolve the ambiguity, we pick-the appropriate component of the product, discarding the rest:--    checkExpOf3 (e, _, _) = e  -- interpret as an expression-    checkCmdOf3 (_, c, _) = c  -- interpret as a command-    checkPatOf3 (_, _, p) = p  -- interpret as a pattern--We can easily define ambiguities between arbitrary subsets of interpretations.-For example, when we know ahead of type that only an expression or a command is-possible, but not a pattern, we can use a smaller type:--    -- See Note [Parser-Validator]-    type ExpCmd = (PV (LHsExpr GhcPs), PV (LHsCmd GhcPs))--    checkExpOf2 (e, _) = e  -- interpret as an expression-    checkCmdOf2 (_, c) = c  -- interpret as a command--However, there is a slight problem with this approach, namely code duplication-in parser productions. Consider the 'alts' production used to parse case-of-alternatives:--  alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }-    : alts1     { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }-    | ';' alts  { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }--Under the new scheme, we have to completely duplicate its type signature and-each reduction rule:--  alts :: { ( PV (Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)])) -- as an expression-            , PV (Located ([AddAnn],[LMatch GhcPs (LHsCmd GhcPs)]))  -- as a command-            ) }-    : alts1-        { ( checkExpOf2 $1 >>= \ $1 ->-            return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1)-          , checkCmdOf2 $1 >>= \ $1 ->-            return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1)-          ) }-    | ';' alts-        { ( checkExpOf2 $2 >>= \ $2 ->-            return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2)-          , checkCmdOf2 $2 >>= \ $2 ->-            return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2)-          ) }--And the same goes for other productions: 'altslist', 'alts1', 'alt', 'alt_rhs',-'ralt', 'gdpats', 'gdpat', 'exp', ... and so on. That is a lot of code!--Alternative VIII, a function from a GADT------------------------------------------We could avoid code duplication of the Alternative VII by representing the product-as a function from a GADT:--    data ExpCmdG b where-      ExpG :: ExpCmdG HsExpr-      CmdG :: ExpCmdG HsCmd--    type ExpCmd = forall b. ExpCmdG b -> PV (Located (b GhcPs))--    checkExp :: ExpCmd -> PV (LHsExpr GhcPs)-    checkCmd :: ExpCmd -> PV (LHsCmd GhcPs)-    checkExp f = f ExpG  -- interpret as an expression-    checkCmd f = f CmdG  -- interpret as a command--Consider the 'alts' production used to parse case-of alternatives:--  alts :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }-    : alts1     { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }-    | ';' alts  { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }--We abstract over LHsExpr, and it becomes:--  alts :: { forall b. ExpCmdG b -> PV (Located ([AddAnn],[LMatch GhcPs (Located (b GhcPs))])) }-    : alts1-        { \tag -> $1 tag >>= \ $1 ->-                  return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }-    | ';' alts-        { \tag -> $2 tag >>= \ $2 ->-                  return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }--Note that 'ExpCmdG' is a singleton type, the value is completely-determined by the type:--  when (b~HsExpr),  tag = ExpG-  when (b~HsCmd),   tag = CmdG--This is a clear indication that we can use a class to pass this value behind-the scenes:--  class    ExpCmdI b      where expCmdG :: ExpCmdG b-  instance ExpCmdI HsExpr where expCmdG = ExpG-  instance ExpCmdI HsCmd  where expCmdG = CmdG--And now the 'alts' production is simplified, as we no longer need to-thread 'tag' explicitly:--  alts :: { forall b. ExpCmdI b => PV (Located ([AddAnn],[LMatch GhcPs (Located (b GhcPs))])) }-    : alts1     { $1 >>= \ $1 ->-                  return $ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }-    | ';' alts  { $2 >>= \ $2 ->-                  return $ sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2)),snd $ unLoc $2) }--This encoding works well enough, but introduces an extra GADT unlike the-tagless final encoding, and there's no need for this complexity.---}--{- Note [PatBuilder]-~~~~~~~~~~~~~~~~~~~~-Unlike HsExpr or HsCmd, the Pat type cannot accommodate all intermediate forms,-so we introduce the notion of a PatBuilder.--Consider a pattern like this:--  Con a b c--We parse arguments to "Con" one at a time in the  fexp aexp  parser production,-building the result with mkHsAppPV, so the intermediate forms are:--  1. Con-  2. Con a-  3. Con a b-  4. Con a b c--In 'HsExpr', we have 'HsApp', so the intermediate forms are represented like-this (pseudocode):--  1. "Con"-  2. HsApp "Con" "a"-  3. HsApp (HsApp "Con" "a") "b"-  3. HsApp (HsApp (HsApp "Con" "a") "b") "c"--Similarly, in 'HsCmd' we have 'HsCmdApp'. In 'Pat', however, what we have-instead is 'ConPatIn', which is very awkward to modify and thus unsuitable for-the intermediate forms.--We also need an intermediate representation to postpone disambiguation between-FunBind and PatBind. Consider:--  a `Con` b = ...-  a `fun` b = ...--How do we know that (a `Con` b) is a PatBind but (a `fun` b) is a FunBind? We-learn this by inspecting an intermediate representation in 'isFunLhs' and-seeing that 'Con' is a data constructor but 'f' is not. We need an intermediate-representation capable of representing both a FunBind and a PatBind, so Pat is-insufficient.--PatBuilder is an extension of Pat that is capable of representing intermediate-parsing results for patterns and function bindings:--  data PatBuilder p-    = PatBuilderPat (Pat p)-    | PatBuilderApp (Located (PatBuilder p)) (Located (PatBuilder p))-    | PatBuilderOpApp (Located (PatBuilder p)) (Located RdrName) (Located (PatBuilder p))-    ...--It can represent any pattern via 'PatBuilderPat', but it also has a variety of-other constructors which were added by following a simple principle: we never-pattern match on the pattern stored inside 'PatBuilderPat'.--}-------------------------------------------------------------------------------- Miscellaneous utilities---- | Check if a fixity is valid. We support bypassing the usual bound checks--- for some special operators.-checkPrecP-        :: Located (SourceText,Int)             -- ^ precedence-        -> Located (OrdList (Located RdrName))  -- ^ operators-        -> P ()-checkPrecP (L l (_,i)) (L _ ol)- | 0 <= i, i <= maxPrecedence = pure ()- | all specialOp ol = pure ()- | otherwise = addFatalError l (text ("Precedence out of range: " ++ show i))-  where-    specialOp op = unLoc op `elem` [ eqTyCon_RDR-                                   , getRdrName funTyCon ]--mkRecConstrOrUpdate-        :: LHsExpr GhcPs-        -> SrcSpan-        -> ([LHsRecField GhcPs (LHsExpr GhcPs)], Maybe SrcSpan)-        -> PV (HsExpr GhcPs)--mkRecConstrOrUpdate (L l (HsVar _ (L _ c))) _ (fs,dd)-  | isRdrDataCon c-  = return (mkRdrRecordCon (L l c) (mk_rec_fields fs dd))-mkRecConstrOrUpdate exp _ (fs,dd)-  | Just dd_loc <- dd = addFatalError dd_loc (text "You cannot use `..' in a record update")-  | otherwise = return (mkRdrRecordUpd exp (map (fmap mk_rec_upd_field) fs))--mkRdrRecordUpd :: LHsExpr GhcPs -> [LHsRecUpdField GhcPs] -> HsExpr GhcPs-mkRdrRecordUpd exp flds-  = RecordUpd { rupd_ext  = noExtField-              , rupd_expr = exp-              , rupd_flds = flds }--mkRdrRecordCon :: Located RdrName -> HsRecordBinds GhcPs -> HsExpr GhcPs-mkRdrRecordCon con flds-  = RecordCon { rcon_ext = noExtField, rcon_con_name = con, rcon_flds = flds }--mk_rec_fields :: [LHsRecField id arg] -> Maybe SrcSpan -> HsRecFields id arg-mk_rec_fields fs Nothing = HsRecFields { rec_flds = fs, rec_dotdot = Nothing }-mk_rec_fields fs (Just s)  = HsRecFields { rec_flds = fs-                                     , rec_dotdot = Just (L s (length fs)) }--mk_rec_upd_field :: HsRecField GhcPs (LHsExpr GhcPs) -> HsRecUpdField GhcPs-mk_rec_upd_field (HsRecField (L loc (FieldOcc _ rdr)) arg pun)-  = HsRecField (L loc (Unambiguous noExtField rdr)) arg pun-mk_rec_upd_field (HsRecField (L _ (XFieldOcc nec)) _ _)-  = noExtCon nec--mkInlinePragma :: SourceText -> (InlineSpec, RuleMatchInfo) -> Maybe Activation-               -> InlinePragma--- The (Maybe Activation) is because the user can omit--- the activation spec (and usually does)-mkInlinePragma src (inl, match_info) mb_act-  = InlinePragma { inl_src = src -- Note [Pragma source text] in GHC.Types.Basic-                 , inl_inline = inl-                 , inl_sat    = Nothing-                 , inl_act    = act-                 , inl_rule   = match_info }-  where-    act = case mb_act of-            Just act -> act-            Nothing  -> -- No phase specified-                        case inl of-                          NoInline -> NeverActive-                          _other   -> AlwaysActive---------------------------------------------------------------------------------- utilities for foreign declarations---- construct a foreign import declaration----mkImport :: Located CCallConv-         -> Located Safety-         -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs)-         -> P (HsDecl GhcPs)-mkImport cconv safety (L loc (StringLiteral esrc entity), v, ty) =-    case unLoc cconv of-      CCallConv          -> mkCImport-      CApiConv           -> mkCImport-      StdCallConv        -> mkCImport-      PrimCallConv       -> mkOtherImport-      JavaScriptCallConv -> mkOtherImport-  where-    -- Parse a C-like entity string of the following form:-    --   "[static] [chname] [&] [cid]" | "dynamic" | "wrapper"-    -- If 'cid' is missing, the function name 'v' is used instead as symbol-    -- name (cf section 8.5.1 in Haskell 2010 report).-    mkCImport = do-      let e = unpackFS entity-      case parseCImport cconv safety (mkExtName (unLoc v)) e (L loc esrc) of-        Nothing         -> addFatalError loc (text "Malformed entity string")-        Just importSpec -> returnSpec importSpec--    -- currently, all the other import conventions only support a symbol name in-    -- the entity string. If it is missing, we use the function name instead.-    mkOtherImport = returnSpec importSpec-      where-        entity'    = if nullFS entity-                        then mkExtName (unLoc v)-                        else entity-        funcTarget = CFunction (StaticTarget esrc entity' Nothing True)-        importSpec = CImport cconv safety Nothing funcTarget (L loc esrc)--    returnSpec spec = return $ ForD noExtField $ ForeignImport-          { fd_i_ext  = noExtField-          , fd_name   = v-          , fd_sig_ty = ty-          , fd_fi     = spec-          }------ the string "foo" is ambiguous: either a header or a C identifier.  The--- C identifier case comes first in the alternatives below, so we pick--- that one.-parseCImport :: Located CCallConv -> Located Safety -> FastString -> String-             -> Located SourceText-             -> Maybe ForeignImport-parseCImport cconv safety nm str sourceText =- listToMaybe $ map fst $ filter (null.snd) $-     readP_to_S parse str- where-   parse = do-       skipSpaces-       r <- choice [-          string "dynamic" >> return (mk Nothing (CFunction DynamicTarget)),-          string "wrapper" >> return (mk Nothing CWrapper),-          do optional (token "static" >> skipSpaces)-             ((mk Nothing <$> cimp nm) +++-              (do h <- munch1 hdr_char-                  skipSpaces-                  mk (Just (Header (SourceText h) (mkFastString h)))-                      <$> cimp nm))-         ]-       skipSpaces-       return r--   token str = do _ <- string str-                  toks <- look-                  case toks of-                      c : _-                       | id_char c -> pfail-                      _            -> return ()--   mk h n = CImport cconv safety h n sourceText--   hdr_char c = not (isSpace c)-   -- header files are filenames, which can contain-   -- pretty much any char (depending on the platform),-   -- so just accept any non-space character-   id_first_char c = isAlpha    c || c == '_'-   id_char       c = isAlphaNum c || c == '_'--   cimp nm = (ReadP.char '&' >> skipSpaces >> CLabel <$> cid)-             +++ (do isFun <- case unLoc cconv of-                               CApiConv ->-                                  option True-                                         (do token "value"-                                             skipSpaces-                                             return False)-                               _ -> return True-                     cid' <- cid-                     return (CFunction (StaticTarget NoSourceText cid'-                                        Nothing isFun)))-          where-            cid = return nm +++-                  (do c  <- satisfy id_first_char-                      cs <-  many (satisfy id_char)-                      return (mkFastString (c:cs)))----- construct a foreign export declaration----mkExport :: Located CCallConv-         -> (Located StringLiteral, Located RdrName, LHsSigType GhcPs)-         -> P (HsDecl GhcPs)-mkExport (L lc cconv) (L le (StringLiteral esrc entity), v, ty)- = return $ ForD noExtField $-   ForeignExport { fd_e_ext = noExtField, fd_name = v, fd_sig_ty = ty-                 , fd_fe = CExport (L lc (CExportStatic esrc entity' cconv))-                                   (L le esrc) }-  where-    entity' | nullFS entity = mkExtName (unLoc v)-            | otherwise     = entity---- Supplying the ext_name in a foreign decl is optional; if it--- isn't there, the Haskell name is assumed. Note that no transformation--- of the Haskell name is then performed, so if you foreign export (++),--- it's external name will be "++". Too bad; it's important because we don't--- want z-encoding (e.g. names with z's in them shouldn't be doubled)----mkExtName :: RdrName -> CLabelString-mkExtName rdrNm = mkFastString (occNameString (rdrNameOcc rdrNm))------------------------------------------------------------------------------------- Help with module system imports/exports--data ImpExpSubSpec = ImpExpAbs-                   | ImpExpAll-                   | ImpExpList [Located ImpExpQcSpec]-                   | ImpExpAllWith [Located ImpExpQcSpec]--data ImpExpQcSpec = ImpExpQcName (Located RdrName)-                  | ImpExpQcType (Located RdrName)-                  | ImpExpQcWildcard--mkModuleImpExp :: Located ImpExpQcSpec -> ImpExpSubSpec -> P (IE GhcPs)-mkModuleImpExp (L l specname) subs =-  case subs of-    ImpExpAbs-      | isVarNameSpace (rdrNameSpace name)-                       -> return $ IEVar noExtField (L l (ieNameFromSpec specname))-      | otherwise      -> IEThingAbs noExtField . L l <$> nameT-    ImpExpAll          -> IEThingAll noExtField . L l <$> nameT-    ImpExpList xs      ->-      (\newName -> IEThingWith noExtField (L l newName)-        NoIEWildcard (wrapped xs) []) <$> nameT-    ImpExpAllWith xs                       ->-      do allowed <- getBit PatternSynonymsBit-         if allowed-          then-            let withs = map unLoc xs-                pos   = maybe NoIEWildcard IEWildcard-                          (findIndex isImpExpQcWildcard withs)-                ies   = wrapped $ filter (not . isImpExpQcWildcard . unLoc) xs-            in (\newName-                        -> IEThingWith noExtField (L l newName) pos ies [])-               <$> nameT-          else addFatalError l-            (text "Illegal export form (use PatternSynonyms to enable)")-  where-    name = ieNameVal specname-    nameT =-      if isVarNameSpace (rdrNameSpace name)-        then addFatalError l-              (text "Expecting a type constructor but found a variable,"-               <+> quotes (ppr name) <> text "."-              $$ if isSymOcc $ rdrNameOcc name-                   then text "If" <+> quotes (ppr name)-                        <+> text "is a type constructor"-           <+> text "then enable ExplicitNamespaces and use the 'type' keyword."-                   else empty)-        else return $ ieNameFromSpec specname--    ieNameVal (ImpExpQcName ln)  = unLoc ln-    ieNameVal (ImpExpQcType ln)  = unLoc ln-    ieNameVal (ImpExpQcWildcard) = panic "ieNameVal got wildcard"--    ieNameFromSpec (ImpExpQcName ln)  = IEName ln-    ieNameFromSpec (ImpExpQcType ln)  = IEType ln-    ieNameFromSpec (ImpExpQcWildcard) = panic "ieName got wildcard"--    wrapped = map (mapLoc ieNameFromSpec)--mkTypeImpExp :: Located RdrName   -- TcCls or Var name space-             -> P (Located RdrName)-mkTypeImpExp name =-  do allowed <- getBit ExplicitNamespacesBit-     unless allowed $ addError (getLoc name) $-       text "Illegal keyword 'type' (use ExplicitNamespaces to enable)"-     return (fmap (`setRdrNameSpace` tcClsName) name)--checkImportSpec :: Located [LIE GhcPs] -> P (Located [LIE GhcPs])-checkImportSpec ie@(L _ specs) =-    case [l | (L l (IEThingWith _ _ (IEWildcard _) _ _)) <- specs] of-      [] -> return ie-      (l:_) -> importSpecError l-  where-    importSpecError l =-      addFatalError l-        (text "Illegal import form, this syntax can only be used to bundle"-        $+$ text "pattern synonyms with types in module exports.")---- In the correct order-mkImpExpSubSpec :: [Located ImpExpQcSpec] -> P ([AddAnn], ImpExpSubSpec)-mkImpExpSubSpec [] = return ([], ImpExpList [])-mkImpExpSubSpec [L _ ImpExpQcWildcard] =-  return ([], ImpExpAll)-mkImpExpSubSpec xs =-  if (any (isImpExpQcWildcard . unLoc) xs)-    then return $ ([], ImpExpAllWith xs)-    else return $ ([], ImpExpList xs)--isImpExpQcWildcard :: ImpExpQcSpec -> Bool-isImpExpQcWildcard ImpExpQcWildcard = True-isImpExpQcWildcard _                = False---------------------------------------------------------------------------------- Warnings and failures--warnPrepositiveQualifiedModule :: SrcSpan -> P ()-warnPrepositiveQualifiedModule span =-  addWarning Opt_WarnPrepositiveQualifiedModule span msg-  where-    msg = text "Found" <+> quotes (text "qualified")-           <+> text "in prepositive position"-       $$ text "Suggested fix: place " <+> quotes (text "qualified")-           <+> text "after the module name instead."--failOpNotEnabledImportQualifiedPost :: SrcSpan -> P ()-failOpNotEnabledImportQualifiedPost loc = addError loc msg-  where-    msg = text "Found" <+> quotes (text "qualified")-          <+> text "in postpositive position. "-      $$ text "To allow this, enable language extension 'ImportQualifiedPost'"--failOpImportQualifiedTwice :: SrcSpan -> P ()-failOpImportQualifiedTwice loc = addError loc msg-  where-    msg = text "Multiple occurrences of 'qualified'"--warnStarIsType :: SrcSpan -> P ()-warnStarIsType span = addWarning Opt_WarnStarIsType span msg-  where-    msg =  text "Using" <+> quotes (text "*")-           <+> text "(or its Unicode variant) to mean"-           <+> quotes (text "Data.Kind.Type")-        $$ text "relies on the StarIsType extension, which will become"-        $$ text "deprecated in the future."-        $$ text "Suggested fix: use" <+> quotes (text "Type")-           <+> text "from" <+> quotes (text "Data.Kind") <+> text "instead."--warnStarBndr :: SrcSpan -> P ()-warnStarBndr span = addWarning Opt_WarnStarBinder span msg-  where-    msg =  text "Found binding occurrence of" <+> quotes (text "*")-           <+> text "yet StarIsType is enabled."-        $$ text "NB. To use (or export) this operator in"-           <+> text "modules with StarIsType,"-        $$ text "    including the definition module, you must qualify it."--failOpFewArgs :: Located RdrName -> P a-failOpFewArgs (L loc op) =-  do { star_is_type <- getBit StarIsTypeBit-     ; let msg = too_few $$ starInfo star_is_type op-     ; addFatalError loc msg }-  where-    too_few = text "Operator applied to too few arguments:" <+> ppr op--failOpDocPrev :: SrcSpan -> P a-failOpDocPrev loc = addFatalError loc msg-  where-    msg = text "Unexpected documentation comment."---------------------------------------------------------------------------------- Misc utils--data PV_Context =-  PV_Context-    { pv_options :: ParserFlags-    , pv_hint :: SDoc  -- See Note [Parser-Validator Hint]-    }--data PV_Accum =-  PV_Accum-    { pv_messages :: DynFlags -> Messages-    , 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---- See Note [Parser-Validator]-newtype PV a = PV { unPV :: PV_Context -> PV_Accum -> PV_Result a }--instance Functor PV where-  fmap = liftM--instance Applicative PV where-  pure a = a `seq` PV (\_ acc -> PV_Ok acc a)-  (<*>) = ap--instance Monad PV where-  m >>= f = PV $ \ctx acc ->-    case unPV m ctx acc of-      PV_Ok acc' a -> unPV (f a) ctx acc'-      PV_Failed acc' -> PV_Failed acc'--runPV :: PV a -> P a-runPV = runPV_msg empty--runPV_msg :: SDoc -> PV a -> P a-runPV_msg msg m =-  P $ \s ->-    let-      pv_ctx = PV_Context-        { pv_options = options s-        , pv_hint = msg }-      pv_acc = PV_Accum-        { pv_messages = messages s-        , pv_annotations = annotations s-        , pv_comment_q = comment_q s-        , pv_annotations_comments = annotations_comments s }-      mkPState acc' =-        s { messages = pv_messages acc'-          , annotations = pv_annotations acc'-          , comment_q = pv_comment_q acc'-          , annotations_comments = pv_annotations_comments acc' }-    in-      case unPV m pv_ctx pv_acc of-        PV_Ok acc' a -> POk (mkPState acc') a-        PV_Failed acc' -> PFailed (mkPState acc')--localPV_msg :: (SDoc -> SDoc) -> PV a -> PV a-localPV_msg f m =-  let modifyHint ctx = ctx{pv_hint = f (pv_hint ctx)} in-  PV (\ctx acc -> unPV m (modifyHint ctx) acc)--instance MonadP PV where-  addError srcspan msg =-    PV $ \ctx acc@PV_Accum{pv_messages=m} ->-      let msg' = msg $$ pv_hint ctx in-      PV_Ok acc{pv_messages=appendError srcspan msg' m} ()-  addWarning option srcspan warning =-    PV $ \PV_Context{pv_options=o} acc@PV_Accum{pv_messages=m} ->-      PV_Ok acc{pv_messages=appendWarning o option srcspan warning m} ()-  addFatalError srcspan msg =-    addError srcspan msg >> PV (const PV_Failed)-  getBit ext =-    PV $ \ctx acc ->-      let b = ext `xtest` pExtsBitmap (pv_options ctx) in-      PV_Ok acc $! b-  addAnnotation (RealSrcSpan l _) a (RealSrcSpan v _) =-    PV $ \_ acc ->-      let-        (comment_q', new_ann_comments) = allocateComments l (pv_comment_q acc)-        annotations_comments' = new_ann_comments ++ pv_annotations_comments acc-        annotations' = ((l,a), [v]) : pv_annotations acc-        acc' = acc-          { pv_annotations = annotations'-          , pv_comment_q = comment_q'-          , pv_annotations_comments = annotations_comments' }-      in-        PV_Ok acc' ()-  addAnnotation _ _ _ = return ()--{- Note [Parser-Validator]-~~~~~~~~~~~~~~~~~~~~~~~~~~--When resolving ambiguities, we need to postpone failure to make a choice later.-For example, if we have ambiguity between some A and B, our parser could be--  abParser :: P (Maybe A, Maybe B)--This way we can represent four possible outcomes of parsing:--    (Just a, Nothing)       -- definitely A-    (Nothing, Just b)       -- definitely B-    (Just a, Just b)        -- either A or B-    (Nothing, Nothing)      -- neither A nor B--However, if we want to report informative parse errors, accumulate warnings,-and add API annotations, we are better off using 'P' instead of 'Maybe':--  abParser :: P (P A, P B)--So we have an outer layer of P that consumes the input and builds the inner-layer, which validates the input.--For clarity, we introduce the notion of a parser-validator: a parser that does-not consume any input, but may fail or use other effects. Thus we have:--  abParser :: P (PV A, PV B)---}--{- Note [Parser-Validator Hint]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A PV computation is parametrized by a hint for error messages, which can be set-depending on validation context. We use this in checkPattern to fix #984.--Consider this example, where the user has forgotten a 'do':--  f _ = do-    x <- computation-    case () of-      _ ->-        result <- computation-        case () of () -> undefined--GHC parses it as follows:--  f _ = do-    x <- computation-    (case () of-      _ ->-        result) <- computation-        case () of () -> undefined--Note that this fragment is parsed as a pattern:--  case () of-    _ ->-      result--We attempt to detect such cases and add a hint to the error messages:--  T984.hs:6:9:-    Parse error in pattern: case () of { _ -> result }-    Possibly caused by a missing 'do'?--The "Possibly caused by a missing 'do'?" suggestion is the hint that is passed-as the 'pv_hint' field 'PV_Context'. When validating in a context other than-'bindpat' (a pattern to the left of <-), we set the hint to 'empty' and it has-no effect on the error messages.---}---- | Hint about bang patterns, assuming @BangPatterns@ is off.-hintBangPat :: SrcSpan -> Pat GhcPs -> PV ()-hintBangPat span e = do-    bang_on <- getBit BangPatBit-    unless bang_on $-      addError span-        (text "Illegal bang-pattern (use BangPatterns):" $$ ppr e)--data SumOrTuple b-  = Sum ConTag Arity (Located b)-  | Tuple [Located (Maybe (Located b))]--pprSumOrTuple :: Outputable b => Boxity -> SumOrTuple b -> SDoc-pprSumOrTuple boxity = \case-    Sum alt arity e ->-      parOpen <+> ppr_bars (alt - 1) <+> ppr e <+> ppr_bars (arity - alt)-              <+> parClose-    Tuple xs ->-      parOpen <> (fcat . punctuate comma $ map (maybe empty ppr . unLoc) xs)-              <> parClose-  where-    ppr_bars n = hsep (replicate n (Outputable.char '|'))-    (parOpen, parClose) =-      case boxity of-        Boxed -> (text "(", text ")")-        Unboxed -> (text "(#", text "#)")--mkSumOrTupleExpr :: SrcSpan -> Boxity -> SumOrTuple (HsExpr GhcPs) -> PV (LHsExpr GhcPs)---- Tuple-mkSumOrTupleExpr l boxity (Tuple es) =-    return $ L l (ExplicitTuple noExtField (map toTupArg es) boxity)-  where-    toTupArg :: Located (Maybe (LHsExpr GhcPs)) -> LHsTupArg GhcPs-    toTupArg = mapLoc (maybe missingTupArg (Present noExtField))---- Sum-mkSumOrTupleExpr l Unboxed (Sum alt arity e) =-    return $ L l (ExplicitSum noExtField alt arity e)-mkSumOrTupleExpr l Boxed a@Sum{} =-    addFatalError l (hang (text "Boxed sums not supported:") 2-                      (pprSumOrTuple Boxed a))--mkSumOrTuplePat :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))---- Tuple-mkSumOrTuplePat l boxity (Tuple ps) = do-  ps' <- traverse toTupPat ps-  return $ L l (PatBuilderPat (TuplePat noExtField ps' boxity))-  where-    toTupPat :: Located (Maybe (Located (PatBuilder GhcPs))) -> PV (LPat GhcPs)-    toTupPat (L l p) = case p of-      Nothing -> addFatalError l (text "Tuple section in pattern context")-      Just p' -> checkLPat p'---- Sum-mkSumOrTuplePat l Unboxed (Sum alt arity p) = do-   p' <- checkLPat p-   return $ L l (PatBuilderPat (SumPat noExtField p' alt arity))-mkSumOrTuplePat l Boxed a@Sum{} =-    addFatalError l (hang (text "Boxed sums not supported:") 2-                      (pprSumOrTuple Boxed a))--mkLHsOpTy :: LHsType GhcPs -> Located RdrName -> LHsType GhcPs -> LHsType GhcPs-mkLHsOpTy x op y =-  let loc = getLoc x `combineSrcSpans` getLoc op `combineSrcSpans` getLoc y-  in L loc (mkHsOpTy x op y)--mkLHsDocTy :: LHsType GhcPs -> LHsDocString -> LHsType GhcPs-mkLHsDocTy t doc =-  let loc = getLoc t `combineSrcSpans` getLoc doc-  in L loc (HsDocTy noExtField t doc)--mkLHsDocTyMaybe :: LHsType GhcPs -> Maybe LHsDocString -> LHsType GhcPs-mkLHsDocTyMaybe t = maybe t (mkLHsDocTy t)---------------------------------------------------------------------------------- Token symbols--starSym :: Bool -> String-starSym True = "★"-starSym False = "*"--forallSym :: Bool -> String-forallSym True = "∀"-forallSym False = "forall"
− compiler/prelude/KnownUniques.hs 
@@ -1,180 +0,0 @@-{-# LANGUAGE CPP #-}---- | This is where we define a mapping from Uniques to their associated--- known-key Names for things associated with tuples and sums. We use this--- mapping while deserializing known-key Names in interface file symbol tables,--- which are encoded as their Unique. See Note [Symbol table representation of--- names] for details.-----module KnownUniques-    ( -- * Looking up known-key names-      knownUniqueName--      -- * Getting the 'Unique's of 'Name's-      -- ** Anonymous sums-    , mkSumTyConUnique-    , mkSumDataConUnique-      -- ** Tuples-      -- *** Vanilla-    , mkTupleTyConUnique-    , mkTupleDataConUnique-      -- *** Constraint-    , mkCTupleTyConUnique-    , mkCTupleDataConUnique-    ) where--#include "HsVersions.h"--import GhcPrelude--import TysWiredIn-import GHC.Core.TyCon-import GHC.Core.DataCon-import GHC.Types.Id-import GHC.Types.Basic-import Outputable-import GHC.Types.Unique-import GHC.Types.Name-import Util--import Data.Bits-import Data.Maybe---- | Get the 'Name' associated with a known-key 'Unique'.-knownUniqueName :: Unique -> Maybe Name-knownUniqueName u =-    case tag of-      'z' -> Just $ getUnboxedSumName n-      '4' -> Just $ getTupleTyConName Boxed n-      '5' -> Just $ getTupleTyConName Unboxed n-      '7' -> Just $ getTupleDataConName Boxed n-      '8' -> Just $ getTupleDataConName Unboxed n-      'k' -> Just $ getCTupleTyConName n-      'm' -> Just $ getCTupleDataConUnique n-      _   -> Nothing-  where-    (tag, n) = unpkUnique u------------------------------------------------------- Anonymous sums------ Sum arities start from 2. The encoding is a bit funny: we break up the--- integral part into bitfields for the arity, an alternative index (which is--- taken to be 0xff in the case of the TyCon), and, in the case of a datacon, a--- tag (used to identify the sum's TypeRep binding).------ This layout is chosen to remain compatible with the usual unique allocation--- for wired-in data constructors described in GHC.Types.Unique------ TyCon for sum of arity k:---   00000000 kkkkkkkk 11111100---- TypeRep of TyCon for sum of arity k:---   00000000 kkkkkkkk 11111101------ DataCon for sum of arity k and alternative n (zero-based):---   00000000 kkkkkkkk nnnnnn00------ TypeRep for sum DataCon of arity k and alternative n (zero-based):---   00000000 kkkkkkkk nnnnnn10--mkSumTyConUnique :: Arity -> Unique-mkSumTyConUnique arity =-    ASSERT(arity < 0x3f) -- 0x3f since we only have 6 bits to encode the-                         -- alternative-    mkUnique 'z' (arity `shiftL` 8 .|. 0xfc)--mkSumDataConUnique :: ConTagZ -> Arity -> Unique-mkSumDataConUnique alt arity-  | alt >= arity-  = panic ("mkSumDataConUnique: " ++ show alt ++ " >= " ++ show arity)-  | otherwise-  = mkUnique 'z' (arity `shiftL` 8 + alt `shiftL` 2) {- skip the tycon -}--getUnboxedSumName :: Int -> Name-getUnboxedSumName n-  | n .&. 0xfc == 0xfc-  = case tag of-      0x0 -> tyConName $ sumTyCon arity-      0x1 -> getRep $ sumTyCon arity-      _   -> pprPanic "getUnboxedSumName: invalid tag" (ppr tag)-  | tag == 0x0-  = dataConName $ sumDataCon (alt + 1) arity-  | tag == 0x1-  = getName $ dataConWrapId $ sumDataCon (alt + 1) arity-  | tag == 0x2-  = getRep $ promoteDataCon $ sumDataCon (alt + 1) arity-  | otherwise-  = pprPanic "getUnboxedSumName" (ppr n)-  where-    arity = n `shiftR` 8-    alt = (n .&. 0xfc) `shiftR` 2-    tag = 0x3 .&. n-    getRep tycon =-        fromMaybe (pprPanic "getUnboxedSumName(getRep)" (ppr tycon))-        $ tyConRepName_maybe tycon---- Note [Uniques for tuple type and data constructors]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ Wired-in type constructor keys occupy *two* slots:---    * u: the TyCon itself---    * u+1: the TyConRepName of the TyCon------ Wired-in tuple data constructor keys occupy *three* slots:---    * u: the DataCon itself---    * u+1: its worker Id---    * u+2: the TyConRepName of the promoted TyCon------------------------------------------------------- Constraint tuples--mkCTupleTyConUnique :: Arity -> Unique-mkCTupleTyConUnique a = mkUnique 'k' (2*a)--mkCTupleDataConUnique :: Arity -> Unique-mkCTupleDataConUnique a = mkUnique 'm' (3*a)--getCTupleTyConName :: Int -> Name-getCTupleTyConName n =-    case n `divMod` 2 of-      (arity, 0) -> cTupleTyConName arity-      (arity, 1) -> mkPrelTyConRepName $ cTupleTyConName arity-      _          -> panic "getCTupleTyConName: impossible"--getCTupleDataConUnique :: Int -> Name-getCTupleDataConUnique n =-    case n `divMod` 3 of-      (arity,  0) -> cTupleDataConName arity-      (_arity, 1) -> panic "getCTupleDataConName: no worker"-      (arity,  2) -> mkPrelTyConRepName $ cTupleDataConName arity-      _           -> panic "getCTupleDataConName: impossible"------------------------------------------------------- Normal tuples--mkTupleDataConUnique :: Boxity -> Arity -> Unique-mkTupleDataConUnique Boxed          a = mkUnique '7' (3*a)    -- may be used in C labels-mkTupleDataConUnique Unboxed        a = mkUnique '8' (3*a)--mkTupleTyConUnique :: Boxity -> Arity -> Unique-mkTupleTyConUnique Boxed           a  = mkUnique '4' (2*a)-mkTupleTyConUnique Unboxed         a  = mkUnique '5' (2*a)--getTupleTyConName :: Boxity -> Int -> Name-getTupleTyConName boxity n =-    case n `divMod` 2 of-      (arity, 0) -> tyConName $ tupleTyCon boxity arity-      (arity, 1) -> fromMaybe (panic "getTupleTyConName")-                    $ tyConRepName_maybe $ tupleTyCon boxity arity-      _          -> panic "getTupleTyConName: impossible"--getTupleDataConName :: Boxity -> Int -> Name-getTupleDataConName boxity n =-    case n `divMod` 3 of-      (arity, 0) -> dataConName $ tupleDataCon boxity arity-      (arity, 1) -> idName $ dataConWorkId $ tupleDataCon boxity arity-      (arity, 2) -> fromMaybe (panic "getTupleDataCon")-                    $ tyConRepName_maybe $ promotedTupleDataCon boxity arity-      _          -> panic "getTupleDataConName: impossible"
− compiler/prelude/KnownUniques.hs-boot 
@@ -1,18 +0,0 @@-module KnownUniques where--import GhcPrelude-import GHC.Types.Unique-import GHC.Types.Name-import GHC.Types.Basic---- Needed by TysWiredIn-knownUniqueName :: Unique -> Maybe Name--mkSumTyConUnique :: Arity -> Unique-mkSumDataConUnique :: ConTagZ -> Arity -> Unique--mkCTupleTyConUnique :: Arity -> Unique-mkCTupleDataConUnique :: Arity -> Unique--mkTupleTyConUnique :: Boxity -> Arity -> Unique-mkTupleDataConUnique :: Boxity -> Arity -> Unique
− compiler/prelude/PrelNames.hs 
@@ -1,2489 +0,0 @@-{--(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[PrelNames]{Definitions of prelude modules and names}---Nota Bene: all Names defined in here should come from the base package-- - ModuleNames for prelude modules,-        e.g.    pREL_BASE_Name :: ModuleName-- - Modules for prelude modules-        e.g.    pREL_Base :: Module-- - Uniques for Ids, DataCons, TyCons and Classes that the compiler-   "knows about" in some way-        e.g.    intTyConKey :: Unique-                minusClassOpKey :: Unique-- - Names for Ids, DataCons, TyCons and Classes that the compiler-   "knows about" in some way-        e.g.    intTyConName :: Name-                minusName    :: Name-   One of these Names contains-        (a) the module and occurrence name of the thing-        (b) its Unique-   The way the compiler "knows about" one of these things is-   where the type checker or desugarer needs to look it up. For-   example, when desugaring list comprehensions the desugarer-   needs to conjure up 'foldr'.  It does this by looking up-   foldrName in the environment.-- - RdrNames for Ids, DataCons etc that the compiler may emit into-   generated code (e.g. for deriving).  It's not necessary to know-   the uniques for these guys, only their names---Note [Known-key names]-~~~~~~~~~~~~~~~~~~~~~~-It is *very* important that the compiler gives wired-in things and-things with "known-key" names the correct Uniques wherever they-occur. We have to be careful about this in exactly two places:--  1. When we parse some source code, renaming the AST better yield an-     AST whose Names have the correct uniques--  2. When we read an interface file, the read-in gubbins better have-     the right uniques--This is accomplished through a combination of mechanisms:--  1. When parsing source code, the RdrName-decorated AST has some-     RdrNames which are Exact. These are wired-in RdrNames where the-     we could directly tell from the parsed syntax what Name to-     use. For example, when we parse a [] in a type we can just insert-     an Exact RdrName Name with the listTyConKey.--     Currently, I believe this is just an optimisation: it would be-     equally valid to just output Orig RdrNames that correctly record-     the module etc we expect the final Name to come from. However,-     were we to eliminate isBuiltInOcc_maybe it would become essential-     (see point 3).--  2. The knownKeyNames (which consist of the basicKnownKeyNames from-     the module, and those names reachable via the wired-in stuff from-     TysWiredIn) are used to initialise the "OrigNameCache" in-     GHC.Iface.Env.  This initialization ensures that when the type checker-     or renamer (both of which use GHC.Iface.Env) look up an original name-     (i.e. a pair of a Module and an OccName) for a known-key name-     they get the correct Unique.--     This is the most important mechanism for ensuring that known-key-     stuff gets the right Unique, and is why it is so important to-     place your known-key names in the appropriate lists.--  3. For "infinite families" of known-key names (i.e. tuples and sums), we-     have to be extra careful. Because there are an infinite number of-     these things, we cannot add them to the list of known-key names-     used to initialise the OrigNameCache. Instead, we have to-     rely on never having to look them up in that cache. See-     Note [Infinite families of known-key names] for details.---Note [Infinite families of known-key names]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Infinite families of known-key things (e.g. tuples and sums) pose a tricky-problem: we can't add them to the knownKeyNames finite map which we use to-ensure that, e.g., a reference to (,) gets assigned the right unique (if this-doesn't sound familiar see Note [Known-key names] above).--We instead handle tuples and sums separately from the "vanilla" known-key-things,--  a) The parser recognises them specially and generates an Exact Name (hence not-     looked up in the orig-name cache)--  b) The known infinite families of names are specially serialised by-     GHC.Iface.Binary.putName, with that special treatment detected when we read-     back to ensure that we get back to the correct uniques. See Note [Symbol-     table representation of names] in GHC.Iface.Binary and Note [How tuples-     work] in TysWiredIn.--Most of the infinite families cannot occur in source code, so mechanisms (a) and (b)-suffice to ensure that they always have the right Unique. In particular,-implicit param TyCon names, constraint tuples and Any TyCons cannot be mentioned-by the user. For those things that *can* appear in source programs,--  c) GHC.Iface.Env.lookupOrigNameCache uses isBuiltInOcc_maybe to map built-in syntax-     directly onto the corresponding name, rather than trying to find it in the-     original-name cache.--     See also Note [Built-in syntax and the OrigNameCache]---Note [The integer library]-~~~~~~~~~~~~~~~~~~~~~~~~~~--Clearly, we need to know the names of various definitions of the integer-library, e.g. the type itself, `mkInteger` etc. But there are two possible-implementations of the integer library:-- * integer-gmp (fast, but uses libgmp, which may not be available on all-   targets and is GPL licensed)- * integer-simple (slow, but pure Haskell and BSD-licensed)--We want the compiler to work with either one. The way we achieve this is:-- * When compiling the integer-{gmp,simple} library, we pass-     -this-unit-id  integer-wired-in-   to GHC (see the cabal file libraries/integer-{gmp,simple}.- * This way, GHC can use just this UnitID (see Module.integerUnitId) when-   generating code, and the linker will succeed.--Unfortuately, the abstraction is not complete: When using integer-gmp, we-really want to use the S# constructor directly. This is controlled by-the `integerLibrary` field of `DynFlags`: If it is IntegerGMP, we use-this constructor directly (see  CorePrep.lookupIntegerSDataConName)--When GHC reads the package data base, it (internally only) pretends it has UnitId-`integer-wired-in` instead of the actual UnitId (which includes the version-number); just like for `base` and other packages, as described in-Note [Wired-in packages] in GHC.Types.Module. This is done in Packages.findWiredInPackages.--}--{-# LANGUAGE CPP #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}--module PrelNames (-        Unique, Uniquable(..), hasKey,  -- Re-exported for convenience--        ------------------------------------------------------------        module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName-                                --                 (b) Uniques e.g. intTyConKey-                                --                 (c) Groups of classes and types-                                --                 (d) miscellaneous things-                                -- So many that we export them all-    ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.Types.Module-import GHC.Types.Name.Occurrence-import GHC.Types.Name.Reader-import GHC.Types.Unique-import GHC.Types.Name-import GHC.Types.SrcLoc-import FastString--{--************************************************************************-*                                                                      *-     allNameStrings-*                                                                      *-************************************************************************--}--allNameStrings :: [String]--- Infinite list of a,b,c...z, aa, ab, ac, ... etc-allNameStrings = [ c:cs | cs <- "" : allNameStrings, c <- ['a'..'z'] ]--{--************************************************************************-*                                                                      *-\subsection{Local Names}-*                                                                      *-************************************************************************--This *local* name is used by the interactive stuff--}--itName :: Unique -> SrcSpan -> Name-itName uniq loc = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) loc---- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly--- during compiler debugging.-mkUnboundName :: OccName -> Name-mkUnboundName occ = mkInternalName unboundKey occ noSrcSpan--isUnboundName :: Name -> Bool-isUnboundName name = name `hasKey` unboundKey--{--************************************************************************-*                                                                      *-\subsection{Known key Names}-*                                                                      *-************************************************************************--This section tells what the compiler knows about the association of-names with uniques.  These ones are the *non* wired-in ones.  The-wired in ones are defined in TysWiredIn etc.--}--basicKnownKeyNames :: [Name]  -- See Note [Known-key names]-basicKnownKeyNames- = genericTyConNames- ++ [   --  Classes.  *Must* include:-        --      classes that are grabbed by key (e.g., eqClassKey)-        --      classes in "Class.standardClassKeys" (quite a few)-        eqClassName,                    -- mentioned, derivable-        ordClassName,                   -- derivable-        boundedClassName,               -- derivable-        numClassName,                   -- mentioned, numeric-        enumClassName,                  -- derivable-        monadClassName,-        functorClassName,-        realClassName,                  -- numeric-        integralClassName,              -- numeric-        fractionalClassName,            -- numeric-        floatingClassName,              -- numeric-        realFracClassName,              -- numeric-        realFloatClassName,             -- numeric-        dataClassName,-        isStringClassName,-        applicativeClassName,-        alternativeClassName,-        foldableClassName,-        traversableClassName,-        semigroupClassName, sappendName,-        monoidClassName, memptyName, mappendName, mconcatName,--        -- The IO type-        -- See Note [TyConRepNames for non-wired-in TyCons]-        ioTyConName, ioDataConName,-        runMainIOName,-        runRWName,--        -- Type representation types-        trModuleTyConName, trModuleDataConName,-        trNameTyConName, trNameSDataConName, trNameDDataConName,-        trTyConTyConName, trTyConDataConName,--        -- Typeable-        typeableClassName,-        typeRepTyConName,-        someTypeRepTyConName,-        someTypeRepDataConName,-        kindRepTyConName,-        kindRepTyConAppDataConName,-        kindRepVarDataConName,-        kindRepAppDataConName,-        kindRepFunDataConName,-        kindRepTYPEDataConName,-        kindRepTypeLitSDataConName,-        kindRepTypeLitDDataConName,-        typeLitSortTyConName,-        typeLitSymbolDataConName,-        typeLitNatDataConName,-        typeRepIdName,-        mkTrTypeName,-        mkTrConName,-        mkTrAppName,-        mkTrFunName,-        typeSymbolTypeRepName, typeNatTypeRepName,-        trGhcPrimModuleName,--        -- KindReps for common cases-        starKindRepName,-        starArrStarKindRepName,-        starArrStarArrStarKindRepName,--        -- Dynamic-        toDynName,--        -- Numeric stuff-        negateName, minusName, geName, eqName,--        -- Conversion functions-        rationalTyConName,-        ratioTyConName, ratioDataConName,-        fromRationalName, fromIntegerName,-        toIntegerName, toRationalName,-        fromIntegralName, realToFracName,--        -- Int# stuff-        divIntName, modIntName,--        -- String stuff-        fromStringName,--        -- Enum stuff-        enumFromName, enumFromThenName,-        enumFromThenToName, enumFromToName,--        -- Applicative stuff-        pureAName, apAName, thenAName,--        -- Functor stuff-        fmapName,--        -- Monad stuff-        thenIOName, bindIOName, returnIOName, failIOName, bindMName, thenMName,-        returnMName, joinMName,--        -- MonadFail-        monadFailClassName, failMName,--        -- MonadFix-        monadFixClassName, mfixName,--        -- Arrow stuff-        arrAName, composeAName, firstAName,-        appAName, choiceAName, loopAName,--        -- Ix stuff-        ixClassName,--        -- Show stuff-        showClassName,--        -- Read stuff-        readClassName,--        -- Stable pointers-        newStablePtrName,--        -- GHC Extensions-        groupWithName,--        -- Strings and lists-        unpackCStringName,-        unpackCStringFoldrName, unpackCStringUtf8Name,--        -- Overloaded lists-        isListClassName,-        fromListName,-        fromListNName,-        toListName,--        -- List operations-        concatName, filterName, mapName,-        zipName, foldrName, buildName, augmentName, appendName,--        -- FFI primitive types that are not wired-in.-        stablePtrTyConName, ptrTyConName, funPtrTyConName,-        int8TyConName, int16TyConName, int32TyConName, int64TyConName,-        word16TyConName, word32TyConName, word64TyConName,--        -- Others-        otherwiseIdName, inlineIdName,-        eqStringName, assertName, breakpointName, breakpointCondName,-        opaqueTyConName,-        assertErrorName, traceName,-        printName, fstName, sndName,-        dollarName,--        -- Integer-        integerTyConName, mkIntegerName,-        integerToWord64Name, integerToInt64Name,-        word64ToIntegerName, int64ToIntegerName,-        plusIntegerName, timesIntegerName, smallIntegerName,-        wordToIntegerName,-        integerToWordName, integerToIntName, minusIntegerName,-        negateIntegerName, eqIntegerPrimName, neqIntegerPrimName,-        absIntegerName, signumIntegerName,-        leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,-        compareIntegerName, quotRemIntegerName, divModIntegerName,-        quotIntegerName, remIntegerName, divIntegerName, modIntegerName,-        floatFromIntegerName, doubleFromIntegerName,-        encodeFloatIntegerName, encodeDoubleIntegerName,-        decodeDoubleIntegerName,-        gcdIntegerName, lcmIntegerName,-        andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,-        shiftLIntegerName, shiftRIntegerName, bitIntegerName,-        integerSDataConName,naturalSDataConName,--        -- Natural-        naturalTyConName,-        naturalFromIntegerName, naturalToIntegerName,-        plusNaturalName, minusNaturalName, timesNaturalName, mkNaturalName,-        wordToNaturalName,--        -- Float/Double-        rationalToFloatName,-        rationalToDoubleName,--        -- Other classes-        randomClassName, randomGenClassName, monadPlusClassName,--        -- Type-level naturals-        knownNatClassName, knownSymbolClassName,--        -- Overloaded labels-        isLabelClassName,--        -- Implicit Parameters-        ipClassName,--        -- Overloaded record fields-        hasFieldClassName,--        -- Call Stacks-        callStackTyConName,-        emptyCallStackName, pushCallStackName,--        -- Source Locations-        srcLocDataConName,--        -- Annotation type checking-        toAnnotationWrapperName--        -- The Ordering type-        , orderingTyConName-        , ordLTDataConName, ordEQDataConName, ordGTDataConName--        -- The SPEC type for SpecConstr-        , specTyConName--        -- The Either type-        , eitherTyConName, leftDataConName, rightDataConName--        -- Plugins-        , pluginTyConName-        , frontendPluginTyConName--        -- Generics-        , genClassName, gen1ClassName-        , datatypeClassName, constructorClassName, selectorClassName--        -- Monad comprehensions-        , guardMName-        , liftMName-        , mzipName--        -- GHCi Sandbox-        , ghciIoClassName, ghciStepIoMName--        -- StaticPtr-        , makeStaticName-        , staticPtrTyConName-        , staticPtrDataConName, staticPtrInfoDataConName-        , fromStaticPtrName--        -- Fingerprint-        , fingerprintDataConName--        -- Custom type errors-        , errorMessageTypeErrorFamName-        , typeErrorTextDataConName-        , typeErrorAppendDataConName-        , typeErrorVAppendDataConName-        , typeErrorShowTypeDataConName--        -- Unsafe coercion proofs-        , unsafeEqualityProofName-        , unsafeEqualityTyConName-        , unsafeReflDataConName-        , unsafeCoercePrimName-        , unsafeCoerceName-    ]--genericTyConNames :: [Name]-genericTyConNames = [-    v1TyConName, u1TyConName, par1TyConName, rec1TyConName,-    k1TyConName, m1TyConName, sumTyConName, prodTyConName,-    compTyConName, rTyConName, dTyConName,-    cTyConName, sTyConName, rec0TyConName,-    d1TyConName, c1TyConName, s1TyConName, noSelTyConName,-    repTyConName, rep1TyConName, uRecTyConName,-    uAddrTyConName, uCharTyConName, uDoubleTyConName,-    uFloatTyConName, uIntTyConName, uWordTyConName,-    prefixIDataConName, infixIDataConName, leftAssociativeDataConName,-    rightAssociativeDataConName, notAssociativeDataConName,-    sourceUnpackDataConName, sourceNoUnpackDataConName,-    noSourceUnpackednessDataConName, sourceLazyDataConName,-    sourceStrictDataConName, noSourceStrictnessDataConName,-    decidedLazyDataConName, decidedStrictDataConName, decidedUnpackDataConName,-    metaDataDataConName, metaConsDataConName, metaSelDataConName-  ]--{--************************************************************************-*                                                                      *-\subsection{Module names}-*                                                                      *-************************************************************************-----MetaHaskell Extension Add a new module here--}--pRELUDE :: Module-pRELUDE         = mkBaseModule_ pRELUDE_NAME--gHC_PRIM, gHC_TYPES, gHC_GENERICS, gHC_MAGIC,-    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_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,-    gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC,-    tYPEABLE, tYPEABLE_INTERNAL, gENERICS,-    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, uNSAFE_COERCE :: Module--gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values-gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")-gHC_MAGIC       = mkPrimModule (fsLit "GHC.Magic")-gHC_CSTRING     = mkPrimModule (fsLit "GHC.CString")-gHC_CLASSES     = mkPrimModule (fsLit "GHC.Classes")-gHC_PRIMOPWRAPPERS = mkPrimModule (fsLit "GHC.PrimopWrappers")--gHC_BASE        = mkBaseModule (fsLit "GHC.Base")-gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")-gHC_GHCI        = mkBaseModule (fsLit "GHC.GHCi")-gHC_GHCI_HELPERS= mkBaseModule (fsLit "GHC.GHCi.Helpers")-gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")-gHC_READ        = mkBaseModule (fsLit "GHC.Read")-gHC_NUM         = mkBaseModule (fsLit "GHC.Num")-gHC_MAYBE       = mkBaseModule (fsLit "GHC.Maybe")-gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")-gHC_NATURAL     = mkBaseModule (fsLit "GHC.Natural")-gHC_LIST        = mkBaseModule (fsLit "GHC.List")-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")-gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")-gHC_IO          = mkBaseModule (fsLit "GHC.IO")-gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")-gHC_ST          = mkBaseModule (fsLit "GHC.ST")-gHC_IX          = mkBaseModule (fsLit "GHC.Ix")-gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")-gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")-gHC_ERR         = mkBaseModule (fsLit "GHC.Err")-gHC_REAL        = mkBaseModule (fsLit "GHC.Real")-gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")-gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")-sYSTEM_IO       = mkBaseModule (fsLit "System.IO")-dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")-tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")-tYPEABLE_INTERNAL = mkBaseModule (fsLit "Data.Typeable.Internal")-gENERICS        = mkBaseModule (fsLit "Data.Data")-rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")-lEX             = mkBaseModule (fsLit "Text.Read.Lex")-gHC_INT         = mkBaseModule (fsLit "GHC.Int")-gHC_WORD        = mkBaseModule (fsLit "GHC.Word")-mONAD           = mkBaseModule (fsLit "Control.Monad")-mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")-mONAD_ZIP       = mkBaseModule (fsLit "Control.Monad.Zip")-mONAD_FAIL      = mkBaseModule (fsLit "Control.Monad.Fail")-aRROW           = mkBaseModule (fsLit "Control.Arrow")-cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")-gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")-rANDOM          = mkBaseModule (fsLit "System.Random")-gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")-cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")-gHC_GENERICS    = mkBaseModule (fsLit "GHC.Generics")-gHC_TYPELITS    = mkBaseModule (fsLit "GHC.TypeLits")-gHC_TYPENATS    = mkBaseModule (fsLit "GHC.TypeNats")-dATA_TYPE_EQUALITY = mkBaseModule (fsLit "Data.Type.Equality")-dATA_COERCE     = mkBaseModule (fsLit "Data.Coerce")-dEBUG_TRACE     = mkBaseModule (fsLit "Debug.Trace")-uNSAFE_COERCE   = mkBaseModule (fsLit "Unsafe.Coerce")--gHC_SRCLOC :: Module-gHC_SRCLOC = mkBaseModule (fsLit "GHC.SrcLoc")--gHC_STACK, gHC_STACK_TYPES :: Module-gHC_STACK = mkBaseModule (fsLit "GHC.Stack")-gHC_STACK_TYPES = mkBaseModule (fsLit "GHC.Stack.Types")--gHC_STATICPTR :: Module-gHC_STATICPTR = mkBaseModule (fsLit "GHC.StaticPtr")--gHC_STATICPTR_INTERNAL :: Module-gHC_STATICPTR_INTERNAL = mkBaseModule (fsLit "GHC.StaticPtr.Internal")--gHC_FINGERPRINT_TYPE :: Module-gHC_FINGERPRINT_TYPE = mkBaseModule (fsLit "GHC.Fingerprint.Type")--gHC_OVER_LABELS :: Module-gHC_OVER_LABELS = mkBaseModule (fsLit "GHC.OverloadedLabels")--gHC_RECORDS :: Module-gHC_RECORDS = mkBaseModule (fsLit "GHC.Records")--mAIN, rOOT_MAIN :: Module-mAIN            = mkMainModule_ mAIN_NAME-rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation--mkInteractiveModule :: Int -> Module--- (mkInteractiveMoudule 9) makes module 'interactive:M9'-mkInteractiveModule n = mkModule interactiveUnitId (mkModuleName ("Ghci" ++ show n))--pRELUDE_NAME, mAIN_NAME :: ModuleName-pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")-mAIN_NAME      = mkModuleNameFS (fsLit "Main")--dATA_ARRAY_PARALLEL_NAME, dATA_ARRAY_PARALLEL_PRIM_NAME :: ModuleName-dATA_ARRAY_PARALLEL_NAME      = mkModuleNameFS (fsLit "Data.Array.Parallel")-dATA_ARRAY_PARALLEL_PRIM_NAME = mkModuleNameFS (fsLit "Data.Array.Parallel.Prim")--mkPrimModule :: FastString -> Module-mkPrimModule m = mkModule primUnitId (mkModuleNameFS m)--mkIntegerModule :: FastString -> Module-mkIntegerModule m = mkModule integerUnitId (mkModuleNameFS m)--mkBaseModule :: FastString -> Module-mkBaseModule m = mkModule baseUnitId (mkModuleNameFS m)--mkBaseModule_ :: ModuleName -> Module-mkBaseModule_ m = mkModule baseUnitId m--mkThisGhcModule :: FastString -> Module-mkThisGhcModule m = mkModule thisGhcUnitId (mkModuleNameFS m)--mkThisGhcModule_ :: ModuleName -> Module-mkThisGhcModule_ m = mkModule thisGhcUnitId m--mkMainModule :: FastString -> Module-mkMainModule m = mkModule mainUnitId (mkModuleNameFS m)--mkMainModule_ :: ModuleName -> Module-mkMainModule_ m = mkModule mainUnitId m--{--************************************************************************-*                                                                      *-                        RdrNames-*                                                                      *-************************************************************************--}--main_RDR_Unqual    :: RdrName-main_RDR_Unqual = mkUnqual varName (fsLit "main")-        -- We definitely don't want an Orig RdrName, because-        -- main might, in principle, be imported into module Main--eq_RDR, ge_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,-    ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName-eq_RDR                  = nameRdrName eqName-ge_RDR                  = nameRdrName geName-le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=")-lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<")-gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")-compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare")-ltTag_RDR               = nameRdrName  ordLTDataConName-eqTag_RDR               = nameRdrName  ordEQDataConName-gtTag_RDR               = nameRdrName  ordGTDataConName--eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR-    :: RdrName-eqClass_RDR             = nameRdrName eqClassName-numClass_RDR            = nameRdrName numClassName-ordClass_RDR            = nameRdrName ordClassName-enumClass_RDR           = nameRdrName enumClassName-monadClass_RDR          = nameRdrName monadClassName--map_RDR, append_RDR :: RdrName-map_RDR                 = nameRdrName mapName-append_RDR              = nameRdrName appendName--foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR-    :: RdrName-foldr_RDR               = nameRdrName foldrName-build_RDR               = nameRdrName buildName-returnM_RDR             = nameRdrName returnMName-bindM_RDR               = nameRdrName bindMName-failM_RDR               = nameRdrName failMName--left_RDR, right_RDR :: RdrName-left_RDR                = nameRdrName leftDataConName-right_RDR               = nameRdrName rightDataConName--fromEnum_RDR, toEnum_RDR :: RdrName-fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")-toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")--enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName-enumFrom_RDR            = nameRdrName enumFromName-enumFromTo_RDR          = nameRdrName enumFromToName-enumFromThen_RDR        = nameRdrName enumFromThenName-enumFromThenTo_RDR      = nameRdrName enumFromThenToName--ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName-ratioDataCon_RDR        = nameRdrName ratioDataConName-plusInteger_RDR         = nameRdrName plusIntegerName-timesInteger_RDR        = nameRdrName timesIntegerName--ioDataCon_RDR :: RdrName-ioDataCon_RDR           = nameRdrName ioDataConName--eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,-    unpackCStringUtf8_RDR :: RdrName-eqString_RDR            = nameRdrName eqStringName-unpackCString_RDR       = nameRdrName unpackCStringName-unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName-unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name--newStablePtr_RDR :: RdrName-newStablePtr_RDR        = nameRdrName newStablePtrName--bindIO_RDR, returnIO_RDR :: RdrName-bindIO_RDR              = nameRdrName bindIOName-returnIO_RDR            = nameRdrName returnIOName--fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName-fromInteger_RDR         = nameRdrName fromIntegerName-fromRational_RDR        = nameRdrName fromRationalName-minus_RDR               = nameRdrName minusName-times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")-plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")--toInteger_RDR, toRational_RDR, fromIntegral_RDR :: RdrName-toInteger_RDR           = nameRdrName toIntegerName-toRational_RDR          = nameRdrName toRationalName-fromIntegral_RDR        = nameRdrName fromIntegralName--stringTy_RDR, fromString_RDR :: RdrName-stringTy_RDR            = tcQual_RDR gHC_BASE (fsLit "String")-fromString_RDR          = nameRdrName fromStringName--fromList_RDR, fromListN_RDR, toList_RDR :: RdrName-fromList_RDR = nameRdrName fromListName-fromListN_RDR = nameRdrName fromListNName-toList_RDR = nameRdrName toListName--compose_RDR :: RdrName-compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")--not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,-    and_RDR, range_RDR, inRange_RDR, index_RDR,-    unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName-and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")-not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")-getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")-succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")-pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")-minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")-maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")-range_RDR               = varQual_RDR gHC_IX (fsLit "range")-inRange_RDR             = varQual_RDR gHC_IX (fsLit "inRange")-index_RDR               = varQual_RDR gHC_IX (fsLit "index")-unsafeIndex_RDR         = varQual_RDR gHC_IX (fsLit "unsafeIndex")-unsafeRangeSize_RDR     = varQual_RDR gHC_IX (fsLit "unsafeRangeSize")--readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,-    readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR, expectP_RDR :: RdrName-readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")-readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")-readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")-readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")-readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")-parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")-choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")-lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")-expectP_RDR             = varQual_RDR gHC_READ (fsLit "expectP")--readField_RDR, readFieldHash_RDR, readSymField_RDR :: RdrName-readField_RDR           = varQual_RDR gHC_READ (fsLit "readField")-readFieldHash_RDR       = varQual_RDR gHC_READ (fsLit "readFieldHash")-readSymField_RDR        = varQual_RDR gHC_READ (fsLit "readSymField")--punc_RDR, ident_RDR, symbol_RDR :: RdrName-punc_RDR                = dataQual_RDR lEX (fsLit "Punc")-ident_RDR               = dataQual_RDR lEX (fsLit "Ident")-symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")--step_RDR, alt_RDR, reset_RDR, prec_RDR, pfail_RDR :: RdrName-step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")-alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")-reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")-prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")-pfail_RDR               = varQual_RDR  rEAD_PREC (fsLit "pfail")--showsPrec_RDR, shows_RDR, showString_RDR,-    showSpace_RDR, showCommaSpace_RDR, showParen_RDR :: RdrName-showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")-shows_RDR               = varQual_RDR gHC_SHOW (fsLit "shows")-showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")-showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")-showCommaSpace_RDR      = varQual_RDR gHC_SHOW (fsLit "showCommaSpace")-showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")--error_RDR :: RdrName-error_RDR = varQual_RDR gHC_ERR (fsLit "error")---- Generics (constructors and functions)-u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR,-  k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR,-  prodDataCon_RDR, comp1DataCon_RDR,-  unPar1_RDR, unRec1_RDR, unK1_RDR, unComp1_RDR,-  from_RDR, from1_RDR, to_RDR, to1_RDR,-  datatypeName_RDR, moduleName_RDR, packageName_RDR, isNewtypeName_RDR,-  conName_RDR, conFixity_RDR, conIsRecord_RDR, selName_RDR,-  prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR,-  rightAssocDataCon_RDR, notAssocDataCon_RDR,-  uAddrDataCon_RDR, uCharDataCon_RDR, uDoubleDataCon_RDR,-  uFloatDataCon_RDR, uIntDataCon_RDR, uWordDataCon_RDR,-  uAddrHash_RDR, uCharHash_RDR, uDoubleHash_RDR,-  uFloatHash_RDR, uIntHash_RDR, uWordHash_RDR :: RdrName--u1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "U1")-par1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Par1")-rec1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Rec1")-k1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "K1")-m1DataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "M1")--l1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "L1")-r1DataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "R1")--prodDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")-comp1DataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "Comp1")--unPar1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unPar1")-unRec1_RDR  = varQual_RDR gHC_GENERICS (fsLit "unRec1")-unK1_RDR    = varQual_RDR gHC_GENERICS (fsLit "unK1")-unComp1_RDR = varQual_RDR gHC_GENERICS (fsLit "unComp1")--from_RDR  = varQual_RDR gHC_GENERICS (fsLit "from")-from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1")-to_RDR    = varQual_RDR gHC_GENERICS (fsLit "to")-to1_RDR   = varQual_RDR gHC_GENERICS (fsLit "to1")--datatypeName_RDR  = varQual_RDR gHC_GENERICS (fsLit "datatypeName")-moduleName_RDR    = varQual_RDR gHC_GENERICS (fsLit "moduleName")-packageName_RDR   = varQual_RDR gHC_GENERICS (fsLit "packageName")-isNewtypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "isNewtype")-selName_RDR       = varQual_RDR gHC_GENERICS (fsLit "selName")-conName_RDR       = varQual_RDR gHC_GENERICS (fsLit "conName")-conFixity_RDR     = varQual_RDR gHC_GENERICS (fsLit "conFixity")-conIsRecord_RDR   = varQual_RDR gHC_GENERICS (fsLit "conIsRecord")--prefixDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Prefix")-infixDataCon_RDR      = dataQual_RDR gHC_GENERICS (fsLit "Infix")-leftAssocDataCon_RDR  = nameRdrName leftAssociativeDataConName-rightAssocDataCon_RDR = nameRdrName rightAssociativeDataConName-notAssocDataCon_RDR   = nameRdrName notAssociativeDataConName--uAddrDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "UAddr")-uCharDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "UChar")-uDoubleDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "UDouble")-uFloatDataCon_RDR  = dataQual_RDR gHC_GENERICS (fsLit "UFloat")-uIntDataCon_RDR    = dataQual_RDR gHC_GENERICS (fsLit "UInt")-uWordDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit "UWord")--uAddrHash_RDR   = varQual_RDR gHC_GENERICS (fsLit "uAddr#")-uCharHash_RDR   = varQual_RDR gHC_GENERICS (fsLit "uChar#")-uDoubleHash_RDR = varQual_RDR gHC_GENERICS (fsLit "uDouble#")-uFloatHash_RDR  = varQual_RDR gHC_GENERICS (fsLit "uFloat#")-uIntHash_RDR    = varQual_RDR gHC_GENERICS (fsLit "uInt#")-uWordHash_RDR   = varQual_RDR gHC_GENERICS (fsLit "uWord#")--fmap_RDR, replace_RDR, pure_RDR, ap_RDR, liftA2_RDR, foldable_foldr_RDR,-    foldMap_RDR, null_RDR, all_RDR, traverse_RDR, mempty_RDR,-    mappend_RDR :: RdrName-fmap_RDR                = nameRdrName fmapName-replace_RDR             = varQual_RDR gHC_BASE (fsLit "<$")-pure_RDR                = nameRdrName pureAName-ap_RDR                  = nameRdrName apAName-liftA2_RDR              = varQual_RDR gHC_BASE (fsLit "liftA2")-foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")-foldMap_RDR             = varQual_RDR dATA_FOLDABLE       (fsLit "foldMap")-null_RDR                = varQual_RDR dATA_FOLDABLE       (fsLit "null")-all_RDR                 = varQual_RDR dATA_FOLDABLE       (fsLit "all")-traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")-mempty_RDR              = nameRdrName memptyName-mappend_RDR             = nameRdrName mappendName-------------------------varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR-    :: Module -> FastString -> RdrName-varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)-tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)-clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)-dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)--{--************************************************************************-*                                                                      *-\subsection{Known-key names}-*                                                                      *-************************************************************************--Many of these Names are not really "built in", but some parts of the-compiler (notably the deriving mechanism) need to mention their names,-and it's convenient to write them all down in one place.--}--wildCardName :: Name-wildCardName = mkSystemVarName wildCardKey (fsLit "wild")--runMainIOName, runRWName :: Name-runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey-runRWName     = varQual gHC_MAGIC       (fsLit "runRW#")    runRWKey--orderingTyConName, ordLTDataConName, ordEQDataConName, ordGTDataConName :: Name-orderingTyConName = tcQual  gHC_TYPES (fsLit "Ordering") orderingTyConKey-ordLTDataConName     = dcQual gHC_TYPES (fsLit "LT") ordLTDataConKey-ordEQDataConName     = dcQual gHC_TYPES (fsLit "EQ") ordEQDataConKey-ordGTDataConName     = dcQual gHC_TYPES (fsLit "GT") ordGTDataConKey--specTyConName :: Name-specTyConName     = tcQual gHC_TYPES (fsLit "SPEC") specTyConKey--eitherTyConName, leftDataConName, rightDataConName :: Name-eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey-leftDataConName   = dcQual dATA_EITHER (fsLit "Left")   leftDataConKey-rightDataConName  = dcQual dATA_EITHER (fsLit "Right")  rightDataConKey---- Generics (types)-v1TyConName, u1TyConName, par1TyConName, rec1TyConName,-  k1TyConName, m1TyConName, sumTyConName, prodTyConName,-  compTyConName, rTyConName, dTyConName,-  cTyConName, sTyConName, rec0TyConName,-  d1TyConName, c1TyConName, s1TyConName, noSelTyConName,-  repTyConName, rep1TyConName, uRecTyConName,-  uAddrTyConName, uCharTyConName, uDoubleTyConName,-  uFloatTyConName, uIntTyConName, uWordTyConName,-  prefixIDataConName, infixIDataConName, leftAssociativeDataConName,-  rightAssociativeDataConName, notAssociativeDataConName,-  sourceUnpackDataConName, sourceNoUnpackDataConName,-  noSourceUnpackednessDataConName, sourceLazyDataConName,-  sourceStrictDataConName, noSourceStrictnessDataConName,-  decidedLazyDataConName, decidedStrictDataConName, decidedUnpackDataConName,-  metaDataDataConName, metaConsDataConName, metaSelDataConName :: Name--v1TyConName  = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey-u1TyConName  = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey-par1TyConName  = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey-rec1TyConName  = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey-k1TyConName  = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey-m1TyConName  = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey--sumTyConName    = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey-prodTyConName   = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey-compTyConName   = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey--rTyConName  = tcQual gHC_GENERICS (fsLit "R") rTyConKey-dTyConName  = tcQual gHC_GENERICS (fsLit "D") dTyConKey-cTyConName  = tcQual gHC_GENERICS (fsLit "C") cTyConKey-sTyConName  = tcQual gHC_GENERICS (fsLit "S") sTyConKey--rec0TyConName  = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey-d1TyConName  = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey-c1TyConName  = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey-s1TyConName  = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey-noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey--repTyConName  = tcQual gHC_GENERICS (fsLit "Rep")  repTyConKey-rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey--uRecTyConName      = tcQual gHC_GENERICS (fsLit "URec") uRecTyConKey-uAddrTyConName     = tcQual gHC_GENERICS (fsLit "UAddr") uAddrTyConKey-uCharTyConName     = tcQual gHC_GENERICS (fsLit "UChar") uCharTyConKey-uDoubleTyConName   = tcQual gHC_GENERICS (fsLit "UDouble") uDoubleTyConKey-uFloatTyConName    = tcQual gHC_GENERICS (fsLit "UFloat") uFloatTyConKey-uIntTyConName      = tcQual gHC_GENERICS (fsLit "UInt") uIntTyConKey-uWordTyConName     = tcQual gHC_GENERICS (fsLit "UWord") uWordTyConKey--prefixIDataConName = dcQual gHC_GENERICS (fsLit "PrefixI")  prefixIDataConKey-infixIDataConName  = dcQual gHC_GENERICS (fsLit "InfixI")   infixIDataConKey-leftAssociativeDataConName  = dcQual gHC_GENERICS (fsLit "LeftAssociative")   leftAssociativeDataConKey-rightAssociativeDataConName = dcQual gHC_GENERICS (fsLit "RightAssociative")  rightAssociativeDataConKey-notAssociativeDataConName   = dcQual gHC_GENERICS (fsLit "NotAssociative")    notAssociativeDataConKey--sourceUnpackDataConName         = dcQual gHC_GENERICS (fsLit "SourceUnpack")         sourceUnpackDataConKey-sourceNoUnpackDataConName       = dcQual gHC_GENERICS (fsLit "SourceNoUnpack")       sourceNoUnpackDataConKey-noSourceUnpackednessDataConName = dcQual gHC_GENERICS (fsLit "NoSourceUnpackedness") noSourceUnpackednessDataConKey-sourceLazyDataConName           = dcQual gHC_GENERICS (fsLit "SourceLazy")           sourceLazyDataConKey-sourceStrictDataConName         = dcQual gHC_GENERICS (fsLit "SourceStrict")         sourceStrictDataConKey-noSourceStrictnessDataConName   = dcQual gHC_GENERICS (fsLit "NoSourceStrictness")   noSourceStrictnessDataConKey-decidedLazyDataConName          = dcQual gHC_GENERICS (fsLit "DecidedLazy")          decidedLazyDataConKey-decidedStrictDataConName        = dcQual gHC_GENERICS (fsLit "DecidedStrict")        decidedStrictDataConKey-decidedUnpackDataConName        = dcQual gHC_GENERICS (fsLit "DecidedUnpack")        decidedUnpackDataConKey--metaDataDataConName  = dcQual gHC_GENERICS (fsLit "MetaData")  metaDataDataConKey-metaConsDataConName  = dcQual gHC_GENERICS (fsLit "MetaCons")  metaConsDataConKey-metaSelDataConName   = dcQual gHC_GENERICS (fsLit "MetaSel")   metaSelDataConKey---- Primitive Int-divIntName, modIntName :: Name-divIntName = varQual gHC_CLASSES (fsLit "divInt#") divIntIdKey-modIntName = varQual gHC_CLASSES (fsLit "modInt#") modIntIdKey---- Base strings Strings-unpackCStringName, unpackCStringFoldrName,-    unpackCStringUtf8Name, eqStringName :: Name-unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey-unpackCStringFoldrName  = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey-unpackCStringUtf8Name   = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey-eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey---- The 'inline' function-inlineIdName :: Name-inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey---- Base classes (Eq, Ord, Functor)-fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name-eqClassName       = clsQual gHC_CLASSES (fsLit "Eq")      eqClassKey-eqName            = varQual gHC_CLASSES (fsLit "==")      eqClassOpKey-ordClassName      = clsQual gHC_CLASSES (fsLit "Ord")     ordClassKey-geName            = varQual gHC_CLASSES (fsLit ">=")      geClassOpKey-functorClassName  = clsQual gHC_BASE    (fsLit "Functor") functorClassKey-fmapName          = varQual gHC_BASE    (fsLit "fmap")    fmapClassOpKey---- Class Monad-monadClassName, thenMName, bindMName, returnMName :: Name-monadClassName     = clsQual gHC_BASE (fsLit "Monad")  monadClassKey-thenMName          = varQual gHC_BASE (fsLit ">>")     thenMClassOpKey-bindMName          = varQual gHC_BASE (fsLit ">>=")    bindMClassOpKey-returnMName        = varQual gHC_BASE (fsLit "return") returnMClassOpKey---- Class MonadFail-monadFailClassName, failMName :: Name-monadFailClassName = clsQual mONAD_FAIL (fsLit "MonadFail") monadFailClassKey-failMName          = varQual mONAD_FAIL (fsLit "fail")      failMClassOpKey---- Class Applicative-applicativeClassName, pureAName, apAName, thenAName :: Name-applicativeClassName = clsQual gHC_BASE (fsLit "Applicative") applicativeClassKey-apAName              = varQual gHC_BASE (fsLit "<*>")         apAClassOpKey-pureAName            = varQual gHC_BASE (fsLit "pure")        pureAClassOpKey-thenAName            = varQual gHC_BASE (fsLit "*>")          thenAClassOpKey---- Classes (Foldable, Traversable)-foldableClassName, traversableClassName :: Name-foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey-traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey---- Classes (Semigroup, Monoid)-semigroupClassName, sappendName :: Name-semigroupClassName = clsQual gHC_BASE       (fsLit "Semigroup") semigroupClassKey-sappendName        = varQual gHC_BASE       (fsLit "<>")        sappendClassOpKey-monoidClassName, memptyName, mappendName, mconcatName :: Name-monoidClassName    = clsQual gHC_BASE       (fsLit "Monoid")    monoidClassKey-memptyName         = varQual gHC_BASE       (fsLit "mempty")    memptyClassOpKey-mappendName        = varQual gHC_BASE       (fsLit "mappend")   mappendClassOpKey-mconcatName        = varQual gHC_BASE       (fsLit "mconcat")   mconcatClassOpKey------ AMP additions--joinMName, alternativeClassName :: Name-joinMName            = varQual gHC_BASE (fsLit "join")        joinMIdKey-alternativeClassName = clsQual mONAD (fsLit "Alternative") alternativeClassKey-----joinMIdKey, apAClassOpKey, pureAClassOpKey, thenAClassOpKey,-    alternativeClassKey :: Unique-joinMIdKey          = mkPreludeMiscIdUnique 750-apAClassOpKey       = mkPreludeMiscIdUnique 751 -- <*>-pureAClassOpKey     = mkPreludeMiscIdUnique 752-thenAClassOpKey     = mkPreludeMiscIdUnique 753-alternativeClassKey = mkPreludeMiscIdUnique 754----- Functions for GHC extensions-groupWithName :: Name-groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey---- Random PrelBase functions-fromStringName, otherwiseIdName, foldrName, buildName, augmentName,-    mapName, appendName, assertName,-    breakpointName, breakpointCondName,-    opaqueTyConName, dollarName :: Name-dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey-otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey-foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey-buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey-augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey-mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey-appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey-assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey-breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey-breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey-opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")     opaqueTyConKey-fromStringName = varQual dATA_STRING (fsLit "fromString") fromStringClassOpKey---- PrelTup-fstName, sndName :: Name-fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey-sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey---- Module GHC.Num-numClassName, fromIntegerName, minusName, negateName :: Name-numClassName      = clsQual gHC_NUM (fsLit "Num")         numClassKey-fromIntegerName   = varQual gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey-minusName         = varQual gHC_NUM (fsLit "-")           minusClassOpKey-negateName        = varQual gHC_NUM (fsLit "negate")      negateClassOpKey--integerTyConName, mkIntegerName, integerSDataConName,-    integerToWord64Name, integerToInt64Name,-    word64ToIntegerName, int64ToIntegerName,-    plusIntegerName, timesIntegerName, smallIntegerName,-    wordToIntegerName,-    integerToWordName, integerToIntName, minusIntegerName,-    negateIntegerName, eqIntegerPrimName, neqIntegerPrimName,-    absIntegerName, signumIntegerName,-    leIntegerPrimName, gtIntegerPrimName, ltIntegerPrimName, geIntegerPrimName,-    compareIntegerName, quotRemIntegerName, divModIntegerName,-    quotIntegerName, remIntegerName, divIntegerName, modIntegerName,-    floatFromIntegerName, doubleFromIntegerName,-    encodeFloatIntegerName, encodeDoubleIntegerName,-    decodeDoubleIntegerName,-    gcdIntegerName, lcmIntegerName,-    andIntegerName, orIntegerName, xorIntegerName, complementIntegerName,-    shiftLIntegerName, shiftRIntegerName, bitIntegerName :: Name-integerTyConName      = tcQual gHC_INTEGER_TYPE (fsLit "Integer")           integerTyConKey-integerSDataConName   = dcQual gHC_INTEGER_TYPE (fsLit "S#")                integerSDataConKey-mkIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "mkInteger")         mkIntegerIdKey-integerToWord64Name   = varQual gHC_INTEGER_TYPE (fsLit "integerToWord64")   integerToWord64IdKey-integerToInt64Name    = varQual gHC_INTEGER_TYPE (fsLit "integerToInt64")    integerToInt64IdKey-word64ToIntegerName   = varQual gHC_INTEGER_TYPE (fsLit "word64ToInteger")   word64ToIntegerIdKey-int64ToIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "int64ToInteger")    int64ToIntegerIdKey-plusIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "plusInteger")       plusIntegerIdKey-timesIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "timesInteger")      timesIntegerIdKey-smallIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "smallInteger")      smallIntegerIdKey-wordToIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "wordToInteger")     wordToIntegerIdKey-integerToWordName     = varQual gHC_INTEGER_TYPE (fsLit "integerToWord")     integerToWordIdKey-integerToIntName      = varQual gHC_INTEGER_TYPE (fsLit "integerToInt")      integerToIntIdKey-minusIntegerName      = varQual gHC_INTEGER_TYPE (fsLit "minusInteger")      minusIntegerIdKey-negateIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "negateInteger")     negateIntegerIdKey-eqIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "eqInteger#")        eqIntegerPrimIdKey-neqIntegerPrimName    = varQual gHC_INTEGER_TYPE (fsLit "neqInteger#")       neqIntegerPrimIdKey-absIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "absInteger")        absIntegerIdKey-signumIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "signumInteger")     signumIntegerIdKey-leIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "leInteger#")        leIntegerPrimIdKey-gtIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "gtInteger#")        gtIntegerPrimIdKey-ltIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "ltInteger#")        ltIntegerPrimIdKey-geIntegerPrimName     = varQual gHC_INTEGER_TYPE (fsLit "geInteger#")        geIntegerPrimIdKey-compareIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "compareInteger")    compareIntegerIdKey-quotRemIntegerName    = varQual gHC_INTEGER_TYPE (fsLit "quotRemInteger")    quotRemIntegerIdKey-divModIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "divModInteger")     divModIntegerIdKey-quotIntegerName       = varQual gHC_INTEGER_TYPE (fsLit "quotInteger")       quotIntegerIdKey-remIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "remInteger")        remIntegerIdKey-divIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "divInteger")        divIntegerIdKey-modIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "modInteger")        modIntegerIdKey-floatFromIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "floatFromInteger")      floatFromIntegerIdKey-doubleFromIntegerName = varQual gHC_INTEGER_TYPE (fsLit "doubleFromInteger")     doubleFromIntegerIdKey-encodeFloatIntegerName  = varQual gHC_INTEGER_TYPE (fsLit "encodeFloatInteger")  encodeFloatIntegerIdKey-encodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "encodeDoubleInteger") encodeDoubleIntegerIdKey-decodeDoubleIntegerName = varQual gHC_INTEGER_TYPE (fsLit "decodeDoubleInteger") decodeDoubleIntegerIdKey-gcdIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "gcdInteger")        gcdIntegerIdKey-lcmIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "lcmInteger")        lcmIntegerIdKey-andIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "andInteger")        andIntegerIdKey-orIntegerName         = varQual gHC_INTEGER_TYPE (fsLit "orInteger")         orIntegerIdKey-xorIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "xorInteger")        xorIntegerIdKey-complementIntegerName = varQual gHC_INTEGER_TYPE (fsLit "complementInteger") complementIntegerIdKey-shiftLIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftLInteger")     shiftLIntegerIdKey-shiftRIntegerName     = varQual gHC_INTEGER_TYPE (fsLit "shiftRInteger")     shiftRIntegerIdKey-bitIntegerName        = varQual gHC_INTEGER_TYPE (fsLit "bitInteger")        bitIntegerIdKey---- GHC.Natural types-naturalTyConName, naturalSDataConName :: Name-naturalTyConName     = tcQual gHC_NATURAL (fsLit "Natural") naturalTyConKey-naturalSDataConName  = dcQual gHC_NATURAL (fsLit "NatS#")   naturalSDataConKey--naturalFromIntegerName :: Name-naturalFromIntegerName = varQual gHC_NATURAL (fsLit "naturalFromInteger") naturalFromIntegerIdKey--naturalToIntegerName, plusNaturalName, minusNaturalName, timesNaturalName,-   mkNaturalName, wordToNaturalName :: Name-naturalToIntegerName  = varQual gHC_NATURAL (fsLit "naturalToInteger")  naturalToIntegerIdKey-plusNaturalName       = varQual gHC_NATURAL (fsLit "plusNatural")       plusNaturalIdKey-minusNaturalName      = varQual gHC_NATURAL (fsLit "minusNatural")      minusNaturalIdKey-timesNaturalName      = varQual gHC_NATURAL (fsLit "timesNatural")      timesNaturalIdKey-mkNaturalName         = varQual gHC_NATURAL (fsLit "mkNatural")         mkNaturalIdKey-wordToNaturalName     = varQual gHC_NATURAL (fsLit "wordToNatural#")    wordToNaturalIdKey---- GHC.Real types and classes-rationalTyConName, ratioTyConName, ratioDataConName, realClassName,-    integralClassName, realFracClassName, fractionalClassName,-    fromRationalName, toIntegerName, toRationalName, fromIntegralName,-    realToFracName :: Name-rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational")     rationalTyConKey-ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio")        ratioTyConKey-ratioDataConName    = dcQual  gHC_REAL (fsLit ":%")           ratioDataConKey-realClassName       = clsQual gHC_REAL (fsLit "Real")         realClassKey-integralClassName   = clsQual gHC_REAL (fsLit "Integral")     integralClassKey-realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac")     realFracClassKey-fractionalClassName = clsQual gHC_REAL (fsLit "Fractional")   fractionalClassKey-fromRationalName    = varQual gHC_REAL (fsLit "fromRational") fromRationalClassOpKey-toIntegerName       = varQual gHC_REAL (fsLit "toInteger")    toIntegerClassOpKey-toRationalName      = varQual gHC_REAL (fsLit "toRational")   toRationalClassOpKey-fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral")fromIntegralIdKey-realToFracName      = varQual  gHC_REAL (fsLit "realToFrac")  realToFracIdKey---- PrelFloat classes-floatingClassName, realFloatClassName :: Name-floatingClassName  = clsQual gHC_FLOAT (fsLit "Floating")  floatingClassKey-realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey---- other GHC.Float functions-rationalToFloatName, rationalToDoubleName :: Name-rationalToFloatName  = varQual gHC_FLOAT (fsLit "rationalToFloat") rationalToFloatIdKey-rationalToDoubleName = varQual gHC_FLOAT (fsLit "rationalToDouble") rationalToDoubleIdKey---- Class Ix-ixClassName :: Name-ixClassName = clsQual gHC_IX (fsLit "Ix") ixClassKey---- Typeable representation types-trModuleTyConName-  , trModuleDataConName-  , trNameTyConName-  , trNameSDataConName-  , trNameDDataConName-  , trTyConTyConName-  , trTyConDataConName-  :: Name-trModuleTyConName     = tcQual gHC_TYPES          (fsLit "Module")         trModuleTyConKey-trModuleDataConName   = dcQual gHC_TYPES          (fsLit "Module")         trModuleDataConKey-trNameTyConName       = tcQual gHC_TYPES          (fsLit "TrName")         trNameTyConKey-trNameSDataConName    = dcQual gHC_TYPES          (fsLit "TrNameS")        trNameSDataConKey-trNameDDataConName    = dcQual gHC_TYPES          (fsLit "TrNameD")        trNameDDataConKey-trTyConTyConName      = tcQual gHC_TYPES          (fsLit "TyCon")          trTyConTyConKey-trTyConDataConName    = dcQual gHC_TYPES          (fsLit "TyCon")          trTyConDataConKey--kindRepTyConName-  , kindRepTyConAppDataConName-  , kindRepVarDataConName-  , kindRepAppDataConName-  , kindRepFunDataConName-  , kindRepTYPEDataConName-  , kindRepTypeLitSDataConName-  , kindRepTypeLitDDataConName-  :: Name-kindRepTyConName      = tcQual gHC_TYPES          (fsLit "KindRep")        kindRepTyConKey-kindRepTyConAppDataConName = dcQual gHC_TYPES     (fsLit "KindRepTyConApp") kindRepTyConAppDataConKey-kindRepVarDataConName = dcQual gHC_TYPES          (fsLit "KindRepVar")     kindRepVarDataConKey-kindRepAppDataConName = dcQual gHC_TYPES          (fsLit "KindRepApp")     kindRepAppDataConKey-kindRepFunDataConName = dcQual gHC_TYPES          (fsLit "KindRepFun")     kindRepFunDataConKey-kindRepTYPEDataConName = dcQual gHC_TYPES         (fsLit "KindRepTYPE")    kindRepTYPEDataConKey-kindRepTypeLitSDataConName = dcQual gHC_TYPES     (fsLit "KindRepTypeLitS") kindRepTypeLitSDataConKey-kindRepTypeLitDDataConName = dcQual gHC_TYPES     (fsLit "KindRepTypeLitD") kindRepTypeLitDDataConKey--typeLitSortTyConName-  , typeLitSymbolDataConName-  , typeLitNatDataConName-  :: Name-typeLitSortTyConName     = tcQual gHC_TYPES       (fsLit "TypeLitSort")    typeLitSortTyConKey-typeLitSymbolDataConName = dcQual gHC_TYPES       (fsLit "TypeLitSymbol")  typeLitSymbolDataConKey-typeLitNatDataConName    = dcQual gHC_TYPES       (fsLit "TypeLitNat")     typeLitNatDataConKey---- Class Typeable, and functions for constructing `Typeable` dictionaries-typeableClassName-  , typeRepTyConName-  , someTypeRepTyConName-  , someTypeRepDataConName-  , mkTrTypeName-  , mkTrConName-  , mkTrAppName-  , mkTrFunName-  , typeRepIdName-  , typeNatTypeRepName-  , typeSymbolTypeRepName-  , trGhcPrimModuleName-  :: Name-typeableClassName     = clsQual tYPEABLE_INTERNAL (fsLit "Typeable")       typeableClassKey-typeRepTyConName      = tcQual  tYPEABLE_INTERNAL (fsLit "TypeRep")        typeRepTyConKey-someTypeRepTyConName   = tcQual tYPEABLE_INTERNAL (fsLit "SomeTypeRep")    someTypeRepTyConKey-someTypeRepDataConName = dcQual tYPEABLE_INTERNAL (fsLit "SomeTypeRep")    someTypeRepDataConKey-typeRepIdName         = varQual tYPEABLE_INTERNAL (fsLit "typeRep#")       typeRepIdKey-mkTrTypeName          = varQual tYPEABLE_INTERNAL (fsLit "mkTrType")       mkTrTypeKey-mkTrConName           = varQual tYPEABLE_INTERNAL (fsLit "mkTrCon")        mkTrConKey-mkTrAppName           = varQual tYPEABLE_INTERNAL (fsLit "mkTrApp")        mkTrAppKey-mkTrFunName           = varQual tYPEABLE_INTERNAL (fsLit "mkTrFun")        mkTrFunKey-typeNatTypeRepName    = varQual tYPEABLE_INTERNAL (fsLit "typeNatTypeRep") typeNatTypeRepKey-typeSymbolTypeRepName = varQual tYPEABLE_INTERNAL (fsLit "typeSymbolTypeRep") typeSymbolTypeRepKey--- this is the Typeable 'Module' for GHC.Prim (which has no code, so we place in GHC.Types)--- See Note [Grand plan for Typeable] in TcTypeable.-trGhcPrimModuleName   = varQual gHC_TYPES         (fsLit "tr$ModuleGHCPrim")  trGhcPrimModuleKey---- Typeable KindReps for some common cases-starKindRepName, starArrStarKindRepName, starArrStarArrStarKindRepName :: Name-starKindRepName        = varQual gHC_TYPES         (fsLit "krep$*")         starKindRepKey-starArrStarKindRepName = varQual gHC_TYPES         (fsLit "krep$*Arr*")     starArrStarKindRepKey-starArrStarArrStarKindRepName = varQual gHC_TYPES  (fsLit "krep$*->*->*")   starArrStarArrStarKindRepKey---- Custom type errors-errorMessageTypeErrorFamName-  , typeErrorTextDataConName-  , typeErrorAppendDataConName-  , typeErrorVAppendDataConName-  , typeErrorShowTypeDataConName-  :: Name--errorMessageTypeErrorFamName =-  tcQual gHC_TYPELITS (fsLit "TypeError") errorMessageTypeErrorFamKey--typeErrorTextDataConName =-  dcQual gHC_TYPELITS (fsLit "Text") typeErrorTextDataConKey--typeErrorAppendDataConName =-  dcQual gHC_TYPELITS (fsLit ":<>:") typeErrorAppendDataConKey--typeErrorVAppendDataConName =-  dcQual gHC_TYPELITS (fsLit ":$$:") typeErrorVAppendDataConKey--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-toDynName = varQual dYNAMIC (fsLit "toDyn") toDynIdKey---- Class Data-dataClassName :: Name-dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey---- Error module-assertErrorName    :: Name-assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey---- Debug.Trace-traceName          :: Name-traceName         = varQual dEBUG_TRACE (fsLit "trace") traceKey---- Enum module (Enum, Bounded)-enumClassName, enumFromName, enumFromToName, enumFromThenName,-    enumFromThenToName, boundedClassName :: Name-enumClassName      = clsQual gHC_ENUM (fsLit "Enum")           enumClassKey-enumFromName       = varQual gHC_ENUM (fsLit "enumFrom")       enumFromClassOpKey-enumFromToName     = varQual gHC_ENUM (fsLit "enumFromTo")     enumFromToClassOpKey-enumFromThenName   = varQual gHC_ENUM (fsLit "enumFromThen")   enumFromThenClassOpKey-enumFromThenToName = varQual gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey-boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded")        boundedClassKey---- List functions-concatName, filterName, zipName :: Name-concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey-filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey-zipName           = varQual gHC_LIST (fsLit "zip")    zipIdKey---- Overloaded lists-isListClassName, fromListName, fromListNName, toListName :: Name-isListClassName = clsQual gHC_EXTS (fsLit "IsList")    isListClassKey-fromListName    = varQual gHC_EXTS (fsLit "fromList")  fromListClassOpKey-fromListNName   = varQual gHC_EXTS (fsLit "fromListN") fromListNClassOpKey-toListName      = varQual gHC_EXTS (fsLit "toList")    toListClassOpKey---- Class Show-showClassName :: Name-showClassName   = clsQual gHC_SHOW (fsLit "Show")      showClassKey---- Class Read-readClassName :: Name-readClassName   = clsQual gHC_READ (fsLit "Read")      readClassKey---- Classes Generic and Generic1, Datatype, Constructor and Selector-genClassName, gen1ClassName, datatypeClassName, constructorClassName,-  selectorClassName :: Name-genClassName  = clsQual gHC_GENERICS (fsLit "Generic")  genClassKey-gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey--datatypeClassName    = clsQual gHC_GENERICS (fsLit "Datatype")    datatypeClassKey-constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey-selectorClassName    = clsQual gHC_GENERICS (fsLit "Selector")    selectorClassKey--genericClassNames :: [Name]-genericClassNames = [genClassName, gen1ClassName]---- GHCi things-ghciIoClassName, ghciStepIoMName :: Name-ghciIoClassName = clsQual gHC_GHCI (fsLit "GHCiSandboxIO") ghciIoClassKey-ghciStepIoMName = varQual gHC_GHCI (fsLit "ghciStepIO") ghciStepIoMClassOpKey---- IO things-ioTyConName, ioDataConName,-  thenIOName, bindIOName, returnIOName, failIOName :: Name-ioTyConName       = tcQual  gHC_TYPES (fsLit "IO")       ioTyConKey-ioDataConName     = dcQual  gHC_TYPES (fsLit "IO")       ioDataConKey-thenIOName        = varQual gHC_BASE  (fsLit "thenIO")   thenIOIdKey-bindIOName        = varQual gHC_BASE  (fsLit "bindIO")   bindIOIdKey-returnIOName      = varQual gHC_BASE  (fsLit "returnIO") returnIOIdKey-failIOName        = varQual gHC_IO    (fsLit "failIO")   failIOIdKey---- IO things-printName :: Name-printName         = varQual sYSTEM_IO (fsLit "print") printIdKey---- Int, Word, and Addr things-int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name-int8TyConName     = tcQual gHC_INT  (fsLit "Int8")  int8TyConKey-int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey-int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey-int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey---- Word module-word16TyConName, word32TyConName, word64TyConName :: Name-word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey-word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey-word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey---- PrelPtr module-ptrTyConName, funPtrTyConName :: Name-ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr")    ptrTyConKey-funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey---- Foreign objects and weak pointers-stablePtrTyConName, newStablePtrName :: Name-stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr")    stablePtrTyConKey-newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey---- Recursive-do notation-monadFixClassName, mfixName :: Name-monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey-mfixName           = varQual mONAD_FIX (fsLit "mfix")     mfixIdKey---- Arrow notation-arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name-arrAName           = varQual aRROW (fsLit "arr")       arrAIdKey-composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey-firstAName         = varQual aRROW (fsLit "first")     firstAIdKey-appAName           = varQual aRROW (fsLit "app")       appAIdKey-choiceAName        = varQual aRROW (fsLit "|||")       choiceAIdKey-loopAName          = varQual aRROW (fsLit "loop")      loopAIdKey---- Monad comprehensions-guardMName, liftMName, mzipName :: Name-guardMName         = varQual mONAD (fsLit "guard")    guardMIdKey-liftMName          = varQual mONAD (fsLit "liftM")    liftMIdKey-mzipName           = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey----- Annotation type checking-toAnnotationWrapperName :: Name-toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey---- Other classes, needed for type defaulting-monadPlusClassName, randomClassName, randomGenClassName,-    isStringClassName :: Name-monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")      monadPlusClassKey-randomClassName     = clsQual rANDOM (fsLit "Random")        randomClassKey-randomGenClassName  = clsQual rANDOM (fsLit "RandomGen")     randomGenClassKey-isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey---- Type-level naturals-knownNatClassName :: Name-knownNatClassName     = clsQual gHC_TYPENATS (fsLit "KnownNat") knownNatClassNameKey-knownSymbolClassName :: Name-knownSymbolClassName  = clsQual gHC_TYPELITS (fsLit "KnownSymbol") knownSymbolClassNameKey---- Overloaded labels-isLabelClassName :: Name-isLabelClassName- = clsQual gHC_OVER_LABELS (fsLit "IsLabel") isLabelClassNameKey---- Implicit Parameters-ipClassName :: Name-ipClassName-  = clsQual gHC_CLASSES (fsLit "IP") ipClassKey---- Overloaded record fields-hasFieldClassName :: Name-hasFieldClassName- = clsQual gHC_RECORDS (fsLit "HasField") hasFieldClassNameKey---- Source Locations-callStackTyConName, emptyCallStackName, pushCallStackName,-  srcLocDataConName :: Name-callStackTyConName-  = tcQual gHC_STACK_TYPES  (fsLit "CallStack") callStackTyConKey-emptyCallStackName-  = varQual gHC_STACK_TYPES (fsLit "emptyCallStack") emptyCallStackKey-pushCallStackName-  = varQual gHC_STACK_TYPES (fsLit "pushCallStack") pushCallStackKey-srcLocDataConName-  = dcQual gHC_STACK_TYPES  (fsLit "SrcLoc")    srcLocDataConKey---- plugins-pLUGINS :: Module-pLUGINS = mkThisGhcModule (fsLit "GHC.Driver.Plugins")-pluginTyConName :: Name-pluginTyConName = tcQual pLUGINS (fsLit "Plugin") pluginTyConKey-frontendPluginTyConName :: Name-frontendPluginTyConName = tcQual pLUGINS (fsLit "FrontendPlugin") frontendPluginTyConKey---- Static pointers-makeStaticName :: Name-makeStaticName =-    varQual gHC_STATICPTR_INTERNAL (fsLit "makeStatic") makeStaticKey--staticPtrInfoTyConName :: Name-staticPtrInfoTyConName =-    tcQual gHC_STATICPTR (fsLit "StaticPtrInfo") staticPtrInfoTyConKey--staticPtrInfoDataConName :: Name-staticPtrInfoDataConName =-    dcQual gHC_STATICPTR (fsLit "StaticPtrInfo") staticPtrInfoDataConKey--staticPtrTyConName :: Name-staticPtrTyConName =-    tcQual gHC_STATICPTR (fsLit "StaticPtr") staticPtrTyConKey--staticPtrDataConName :: Name-staticPtrDataConName =-    dcQual gHC_STATICPTR (fsLit "StaticPtr") staticPtrDataConKey--fromStaticPtrName :: Name-fromStaticPtrName =-    varQual gHC_STATICPTR (fsLit "fromStaticPtr") fromStaticPtrClassOpKey--fingerprintDataConName :: Name-fingerprintDataConName =-    dcQual gHC_FINGERPRINT_TYPE (fsLit "Fingerprint") fingerprintDataConKey--{--************************************************************************-*                                                                      *-\subsection{Local helpers}-*                                                                      *-************************************************************************--All these are original names; hence mkOrig--}--varQual, tcQual, clsQual, dcQual :: Module -> FastString -> Unique -> Name-varQual  = mk_known_key_name varName-tcQual   = mk_known_key_name tcName-clsQual  = mk_known_key_name clsName-dcQual   = mk_known_key_name dataName--mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name-mk_known_key_name space modu str unique-  = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan---{--************************************************************************-*                                                                      *-\subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}-*                                                                      *-************************************************************************---MetaHaskell extension hand allocate keys here--}--boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,-    fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,-    functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,-    realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique-boundedClassKey         = mkPreludeClassUnique 1-enumClassKey            = mkPreludeClassUnique 2-eqClassKey              = mkPreludeClassUnique 3-floatingClassKey        = mkPreludeClassUnique 5-fractionalClassKey      = mkPreludeClassUnique 6-integralClassKey        = mkPreludeClassUnique 7-monadClassKey           = mkPreludeClassUnique 8-dataClassKey            = mkPreludeClassUnique 9-functorClassKey         = mkPreludeClassUnique 10-numClassKey             = mkPreludeClassUnique 11-ordClassKey             = mkPreludeClassUnique 12-readClassKey            = mkPreludeClassUnique 13-realClassKey            = mkPreludeClassUnique 14-realFloatClassKey       = mkPreludeClassUnique 15-realFracClassKey        = mkPreludeClassUnique 16-showClassKey            = mkPreludeClassUnique 17-ixClassKey              = mkPreludeClassUnique 18--typeableClassKey :: Unique-typeableClassKey        = mkPreludeClassUnique 20--monadFixClassKey :: Unique-monadFixClassKey        = mkPreludeClassUnique 28--monadFailClassKey :: Unique-monadFailClassKey       = mkPreludeClassUnique 29--monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique-monadPlusClassKey       = mkPreludeClassUnique 30-randomClassKey          = mkPreludeClassUnique 31-randomGenClassKey       = mkPreludeClassUnique 32--isStringClassKey :: Unique-isStringClassKey        = mkPreludeClassUnique 33--applicativeClassKey, foldableClassKey, traversableClassKey :: Unique-applicativeClassKey     = mkPreludeClassUnique 34-foldableClassKey        = mkPreludeClassUnique 35-traversableClassKey     = mkPreludeClassUnique 36--genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey,-  selectorClassKey :: Unique-genClassKey   = mkPreludeClassUnique 37-gen1ClassKey  = mkPreludeClassUnique 38--datatypeClassKey    = mkPreludeClassUnique 39-constructorClassKey = mkPreludeClassUnique 40-selectorClassKey    = mkPreludeClassUnique 41---- KnownNat: see Note [KnowNat & KnownSymbol and EvLit] in TcEvidence-knownNatClassNameKey :: Unique-knownNatClassNameKey = mkPreludeClassUnique 42---- KnownSymbol: see Note [KnownNat & KnownSymbol and EvLit] in TcEvidence-knownSymbolClassNameKey :: Unique-knownSymbolClassNameKey = mkPreludeClassUnique 43--ghciIoClassKey :: Unique-ghciIoClassKey = mkPreludeClassUnique 44--isLabelClassNameKey :: Unique-isLabelClassNameKey = mkPreludeClassUnique 45--semigroupClassKey, monoidClassKey :: Unique-semigroupClassKey = mkPreludeClassUnique 46-monoidClassKey    = mkPreludeClassUnique 47---- Implicit Parameters-ipClassKey :: Unique-ipClassKey = mkPreludeClassUnique 48---- Overloaded record fields-hasFieldClassNameKey :: Unique-hasFieldClassNameKey = mkPreludeClassUnique 49------------------- Template Haskell ----------------------      THNames.hs: USES ClassUniques 200-299--------------------------------------------------------{--************************************************************************-*                                                                      *-\subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}-*                                                                      *-************************************************************************--}--addrPrimTyConKey, arrayPrimTyConKey, arrayArrayPrimTyConKey, boolTyConKey,-    byteArrayPrimTyConKey, charPrimTyConKey, charTyConKey, doublePrimTyConKey,-    doubleTyConKey, floatPrimTyConKey, floatTyConKey, funTyConKey,-    intPrimTyConKey, intTyConKey, int8TyConKey, int16TyConKey,-    int8PrimTyConKey, int16PrimTyConKey, int32PrimTyConKey, int32TyConKey,-    int64PrimTyConKey, int64TyConKey,-    integerTyConKey, naturalTyConKey,-    listTyConKey, foreignObjPrimTyConKey, maybeTyConKey,-    weakPrimTyConKey, mutableArrayPrimTyConKey, mutableArrayArrayPrimTyConKey,-    mutableByteArrayPrimTyConKey, orderingTyConKey, mVarPrimTyConKey,-    ratioTyConKey, rationalTyConKey, realWorldTyConKey, stablePtrPrimTyConKey,-    stablePtrTyConKey, eqTyConKey, heqTyConKey,-    smallArrayPrimTyConKey, smallMutableArrayPrimTyConKey :: Unique-addrPrimTyConKey                        = mkPreludeTyConUnique  1-arrayPrimTyConKey                       = mkPreludeTyConUnique  3-boolTyConKey                            = mkPreludeTyConUnique  4-byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5-charPrimTyConKey                        = mkPreludeTyConUnique  7-charTyConKey                            = mkPreludeTyConUnique  8-doublePrimTyConKey                      = mkPreludeTyConUnique  9-doubleTyConKey                          = mkPreludeTyConUnique 10-floatPrimTyConKey                       = mkPreludeTyConUnique 11-floatTyConKey                           = mkPreludeTyConUnique 12-funTyConKey                             = mkPreludeTyConUnique 13-intPrimTyConKey                         = mkPreludeTyConUnique 14-intTyConKey                             = mkPreludeTyConUnique 15-int8PrimTyConKey                        = mkPreludeTyConUnique 16-int8TyConKey                            = mkPreludeTyConUnique 17-int16PrimTyConKey                       = mkPreludeTyConUnique 18-int16TyConKey                           = mkPreludeTyConUnique 19-int32PrimTyConKey                       = mkPreludeTyConUnique 20-int32TyConKey                           = mkPreludeTyConUnique 21-int64PrimTyConKey                       = mkPreludeTyConUnique 22-int64TyConKey                           = mkPreludeTyConUnique 23-integerTyConKey                         = mkPreludeTyConUnique 24-naturalTyConKey                         = mkPreludeTyConUnique 25--listTyConKey                            = mkPreludeTyConUnique 26-foreignObjPrimTyConKey                  = mkPreludeTyConUnique 27-maybeTyConKey                           = mkPreludeTyConUnique 28-weakPrimTyConKey                        = mkPreludeTyConUnique 29-mutableArrayPrimTyConKey                = mkPreludeTyConUnique 30-mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 31-orderingTyConKey                        = mkPreludeTyConUnique 32-mVarPrimTyConKey                        = mkPreludeTyConUnique 33-ratioTyConKey                           = mkPreludeTyConUnique 34-rationalTyConKey                        = mkPreludeTyConUnique 35-realWorldTyConKey                       = mkPreludeTyConUnique 36-stablePtrPrimTyConKey                   = mkPreludeTyConUnique 37-stablePtrTyConKey                       = mkPreludeTyConUnique 38-eqTyConKey                              = mkPreludeTyConUnique 40-heqTyConKey                             = mkPreludeTyConUnique 41-arrayArrayPrimTyConKey                  = mkPreludeTyConUnique 42-mutableArrayArrayPrimTyConKey           = mkPreludeTyConUnique 43--statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,-    mutVarPrimTyConKey, ioTyConKey,-    wordPrimTyConKey, wordTyConKey, word8PrimTyConKey, word8TyConKey,-    word16PrimTyConKey, word16TyConKey, word32PrimTyConKey, word32TyConKey,-    word64PrimTyConKey, word64TyConKey,-    liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,-    typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,-    funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,-    eqReprPrimTyConKey, eqPhantPrimTyConKey, voidPrimTyConKey,-    compactPrimTyConKey :: Unique-statePrimTyConKey                       = mkPreludeTyConUnique 50-stableNamePrimTyConKey                  = mkPreludeTyConUnique 51-stableNameTyConKey                      = mkPreludeTyConUnique 52-eqPrimTyConKey                          = mkPreludeTyConUnique 53-eqReprPrimTyConKey                      = mkPreludeTyConUnique 54-eqPhantPrimTyConKey                     = mkPreludeTyConUnique 55-mutVarPrimTyConKey                      = mkPreludeTyConUnique 56-ioTyConKey                              = mkPreludeTyConUnique 57-voidPrimTyConKey                        = mkPreludeTyConUnique 58-wordPrimTyConKey                        = mkPreludeTyConUnique 59-wordTyConKey                            = mkPreludeTyConUnique 60-word8PrimTyConKey                       = mkPreludeTyConUnique 61-word8TyConKey                           = mkPreludeTyConUnique 62-word16PrimTyConKey                      = mkPreludeTyConUnique 63-word16TyConKey                          = mkPreludeTyConUnique 64-word32PrimTyConKey                      = mkPreludeTyConUnique 65-word32TyConKey                          = mkPreludeTyConUnique 66-word64PrimTyConKey                      = mkPreludeTyConUnique 67-word64TyConKey                          = mkPreludeTyConUnique 68-liftedConKey                            = mkPreludeTyConUnique 69-unliftedConKey                          = mkPreludeTyConUnique 70-anyBoxConKey                            = mkPreludeTyConUnique 71-kindConKey                              = mkPreludeTyConUnique 72-boxityConKey                            = mkPreludeTyConUnique 73-typeConKey                              = mkPreludeTyConUnique 74-threadIdPrimTyConKey                    = mkPreludeTyConUnique 75-bcoPrimTyConKey                         = mkPreludeTyConUnique 76-ptrTyConKey                             = mkPreludeTyConUnique 77-funPtrTyConKey                          = mkPreludeTyConUnique 78-tVarPrimTyConKey                        = mkPreludeTyConUnique 79-compactPrimTyConKey                     = mkPreludeTyConUnique 80--eitherTyConKey :: Unique-eitherTyConKey                          = mkPreludeTyConUnique 84---- Kind constructors-liftedTypeKindTyConKey, tYPETyConKey,-  constraintKindTyConKey, runtimeRepTyConKey,-  vecCountTyConKey, vecElemTyConKey :: Unique-liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87-tYPETyConKey                            = mkPreludeTyConUnique 88-constraintKindTyConKey                  = mkPreludeTyConUnique 92-runtimeRepTyConKey                      = mkPreludeTyConUnique 95-vecCountTyConKey                        = mkPreludeTyConUnique 96-vecElemTyConKey                         = mkPreludeTyConUnique 97--pluginTyConKey, frontendPluginTyConKey :: Unique-pluginTyConKey                          = mkPreludeTyConUnique 102-frontendPluginTyConKey                  = mkPreludeTyConUnique 103--unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,-    opaqueTyConKey :: Unique-unknownTyConKey                         = mkPreludeTyConUnique 129-unknown1TyConKey                        = mkPreludeTyConUnique 130-unknown2TyConKey                        = mkPreludeTyConUnique 131-unknown3TyConKey                        = mkPreludeTyConUnique 132-opaqueTyConKey                          = mkPreludeTyConUnique 133---- Generics (Unique keys)-v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey,-  k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey,-  compTyConKey, rTyConKey, dTyConKey,-  cTyConKey, sTyConKey, rec0TyConKey,-  d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey,-  repTyConKey, rep1TyConKey, uRecTyConKey,-  uAddrTyConKey, uCharTyConKey, uDoubleTyConKey,-  uFloatTyConKey, uIntTyConKey, uWordTyConKey :: Unique--v1TyConKey    = mkPreludeTyConUnique 135-u1TyConKey    = mkPreludeTyConUnique 136-par1TyConKey  = mkPreludeTyConUnique 137-rec1TyConKey  = mkPreludeTyConUnique 138-k1TyConKey    = mkPreludeTyConUnique 139-m1TyConKey    = mkPreludeTyConUnique 140--sumTyConKey   = mkPreludeTyConUnique 141-prodTyConKey  = mkPreludeTyConUnique 142-compTyConKey  = mkPreludeTyConUnique 143--rTyConKey = mkPreludeTyConUnique 144-dTyConKey = mkPreludeTyConUnique 146-cTyConKey = mkPreludeTyConUnique 147-sTyConKey = mkPreludeTyConUnique 148--rec0TyConKey  = mkPreludeTyConUnique 149-d1TyConKey    = mkPreludeTyConUnique 151-c1TyConKey    = mkPreludeTyConUnique 152-s1TyConKey    = mkPreludeTyConUnique 153-noSelTyConKey = mkPreludeTyConUnique 154--repTyConKey  = mkPreludeTyConUnique 155-rep1TyConKey = mkPreludeTyConUnique 156--uRecTyConKey    = mkPreludeTyConUnique 157-uAddrTyConKey   = mkPreludeTyConUnique 158-uCharTyConKey   = mkPreludeTyConUnique 159-uDoubleTyConKey = mkPreludeTyConUnique 160-uFloatTyConKey  = mkPreludeTyConUnique 161-uIntTyConKey    = mkPreludeTyConUnique 162-uWordTyConKey   = mkPreludeTyConUnique 163---- Type-level naturals-typeNatKindConNameKey, typeSymbolKindConNameKey,-  typeNatAddTyFamNameKey, typeNatMulTyFamNameKey, typeNatExpTyFamNameKey,-  typeNatLeqTyFamNameKey, typeNatSubTyFamNameKey-  , typeSymbolCmpTyFamNameKey, typeNatCmpTyFamNameKey-  , typeNatDivTyFamNameKey-  , typeNatModTyFamNameKey-  , typeNatLogTyFamNameKey-  :: Unique-typeNatKindConNameKey     = mkPreludeTyConUnique 164-typeSymbolKindConNameKey  = mkPreludeTyConUnique 165-typeNatAddTyFamNameKey    = mkPreludeTyConUnique 166-typeNatMulTyFamNameKey    = mkPreludeTyConUnique 167-typeNatExpTyFamNameKey    = mkPreludeTyConUnique 168-typeNatLeqTyFamNameKey    = mkPreludeTyConUnique 169-typeNatSubTyFamNameKey    = mkPreludeTyConUnique 170-typeSymbolCmpTyFamNameKey = mkPreludeTyConUnique 171-typeNatCmpTyFamNameKey    = mkPreludeTyConUnique 172-typeNatDivTyFamNameKey  = mkPreludeTyConUnique 173-typeNatModTyFamNameKey  = mkPreludeTyConUnique 174-typeNatLogTyFamNameKey  = mkPreludeTyConUnique 175---- Custom user type-errors-errorMessageTypeErrorFamKey :: Unique-errorMessageTypeErrorFamKey =  mkPreludeTyConUnique 176----ntTyConKey:: Unique-ntTyConKey = mkPreludeTyConUnique 177-coercibleTyConKey :: Unique-coercibleTyConKey = mkPreludeTyConUnique 178--proxyPrimTyConKey :: Unique-proxyPrimTyConKey = mkPreludeTyConUnique 179--specTyConKey :: Unique-specTyConKey = mkPreludeTyConUnique 180--anyTyConKey :: Unique-anyTyConKey = mkPreludeTyConUnique 181--smallArrayPrimTyConKey        = mkPreludeTyConUnique  182-smallMutableArrayPrimTyConKey = mkPreludeTyConUnique  183--staticPtrTyConKey  :: Unique-staticPtrTyConKey  = mkPreludeTyConUnique 184--staticPtrInfoTyConKey :: Unique-staticPtrInfoTyConKey = mkPreludeTyConUnique 185--callStackTyConKey :: Unique-callStackTyConKey = mkPreludeTyConUnique 186---- Typeables-typeRepTyConKey, someTypeRepTyConKey, someTypeRepDataConKey :: Unique-typeRepTyConKey       = mkPreludeTyConUnique 187-someTypeRepTyConKey   = mkPreludeTyConUnique 188-someTypeRepDataConKey = mkPreludeTyConUnique 189---typeSymbolAppendFamNameKey :: Unique-typeSymbolAppendFamNameKey = mkPreludeTyConUnique 190---- Unsafe equality-unsafeEqualityTyConKey :: Unique-unsafeEqualityTyConKey = mkPreludeTyConUnique 191------------------- Template Haskell ----------------------      THNames.hs: USES TyConUniques 200-299------------------------------------------------------------------------------- SIMD ---------------------------      USES TyConUniques 300-399--------------------------------------------------------#include "primop-vector-uniques.hs-incl"--{--************************************************************************-*                                                                      *-\subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}-*                                                                      *-************************************************************************--}--charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,-    floatDataConKey, intDataConKey, integerSDataConKey, nilDataConKey,-    ratioDataConKey, stableNameDataConKey, trueDataConKey, wordDataConKey,-    word8DataConKey, ioDataConKey, integerDataConKey, heqDataConKey,-    coercibleDataConKey, eqDataConKey, nothingDataConKey, justDataConKey :: Unique--charDataConKey                          = mkPreludeDataConUnique  1-consDataConKey                          = mkPreludeDataConUnique  2-doubleDataConKey                        = mkPreludeDataConUnique  3-falseDataConKey                         = mkPreludeDataConUnique  4-floatDataConKey                         = mkPreludeDataConUnique  5-intDataConKey                           = mkPreludeDataConUnique  6-integerSDataConKey                      = mkPreludeDataConUnique  7-nothingDataConKey                       = mkPreludeDataConUnique  8-justDataConKey                          = mkPreludeDataConUnique  9-eqDataConKey                            = mkPreludeDataConUnique 10-nilDataConKey                           = mkPreludeDataConUnique 11-ratioDataConKey                         = mkPreludeDataConUnique 12-word8DataConKey                         = mkPreludeDataConUnique 13-stableNameDataConKey                    = mkPreludeDataConUnique 14-trueDataConKey                          = mkPreludeDataConUnique 15-wordDataConKey                          = mkPreludeDataConUnique 16-ioDataConKey                            = mkPreludeDataConUnique 17-integerDataConKey                       = mkPreludeDataConUnique 18-heqDataConKey                           = mkPreludeDataConUnique 19---- Generic data constructors-crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique-crossDataConKey                         = mkPreludeDataConUnique 20-inlDataConKey                           = mkPreludeDataConUnique 21-inrDataConKey                           = mkPreludeDataConUnique 22-genUnitDataConKey                       = mkPreludeDataConUnique 23--leftDataConKey, rightDataConKey :: Unique-leftDataConKey                          = mkPreludeDataConUnique 25-rightDataConKey                         = mkPreludeDataConUnique 26--ordLTDataConKey, ordEQDataConKey, ordGTDataConKey :: Unique-ordLTDataConKey                         = mkPreludeDataConUnique 27-ordEQDataConKey                         = mkPreludeDataConUnique 28-ordGTDataConKey                         = mkPreludeDataConUnique 29---coercibleDataConKey                     = mkPreludeDataConUnique 32--staticPtrDataConKey :: Unique-staticPtrDataConKey                     = mkPreludeDataConUnique 33--staticPtrInfoDataConKey :: Unique-staticPtrInfoDataConKey                 = mkPreludeDataConUnique 34--fingerprintDataConKey :: Unique-fingerprintDataConKey                   = mkPreludeDataConUnique 35--srcLocDataConKey :: Unique-srcLocDataConKey                        = mkPreludeDataConUnique 37--trTyConTyConKey, trTyConDataConKey,-  trModuleTyConKey, trModuleDataConKey,-  trNameTyConKey, trNameSDataConKey, trNameDDataConKey,-  trGhcPrimModuleKey, kindRepTyConKey,-  typeLitSortTyConKey :: Unique-trTyConTyConKey                         = mkPreludeDataConUnique 40-trTyConDataConKey                       = mkPreludeDataConUnique 41-trModuleTyConKey                        = mkPreludeDataConUnique 42-trModuleDataConKey                      = mkPreludeDataConUnique 43-trNameTyConKey                          = mkPreludeDataConUnique 44-trNameSDataConKey                       = mkPreludeDataConUnique 45-trNameDDataConKey                       = mkPreludeDataConUnique 46-trGhcPrimModuleKey                      = mkPreludeDataConUnique 47-kindRepTyConKey                         = mkPreludeDataConUnique 48-typeLitSortTyConKey                     = mkPreludeDataConUnique 49--typeErrorTextDataConKey,-  typeErrorAppendDataConKey,-  typeErrorVAppendDataConKey,-  typeErrorShowTypeDataConKey-  :: Unique-typeErrorTextDataConKey                 = mkPreludeDataConUnique 50-typeErrorAppendDataConKey               = mkPreludeDataConUnique 51-typeErrorVAppendDataConKey              = mkPreludeDataConUnique 52-typeErrorShowTypeDataConKey             = mkPreludeDataConUnique 53--prefixIDataConKey, infixIDataConKey, leftAssociativeDataConKey,-    rightAssociativeDataConKey, notAssociativeDataConKey,-    sourceUnpackDataConKey, sourceNoUnpackDataConKey,-    noSourceUnpackednessDataConKey, sourceLazyDataConKey,-    sourceStrictDataConKey, noSourceStrictnessDataConKey,-    decidedLazyDataConKey, decidedStrictDataConKey, decidedUnpackDataConKey,-    metaDataDataConKey, metaConsDataConKey, metaSelDataConKey :: Unique-prefixIDataConKey                       = mkPreludeDataConUnique 54-infixIDataConKey                        = mkPreludeDataConUnique 55-leftAssociativeDataConKey               = mkPreludeDataConUnique 56-rightAssociativeDataConKey              = mkPreludeDataConUnique 57-notAssociativeDataConKey                = mkPreludeDataConUnique 58-sourceUnpackDataConKey                  = mkPreludeDataConUnique 59-sourceNoUnpackDataConKey                = mkPreludeDataConUnique 60-noSourceUnpackednessDataConKey          = mkPreludeDataConUnique 61-sourceLazyDataConKey                    = mkPreludeDataConUnique 62-sourceStrictDataConKey                  = mkPreludeDataConUnique 63-noSourceStrictnessDataConKey            = mkPreludeDataConUnique 64-decidedLazyDataConKey                   = mkPreludeDataConUnique 65-decidedStrictDataConKey                 = mkPreludeDataConUnique 66-decidedUnpackDataConKey                 = mkPreludeDataConUnique 67-metaDataDataConKey                      = mkPreludeDataConUnique 68-metaConsDataConKey                      = mkPreludeDataConUnique 69-metaSelDataConKey                       = mkPreludeDataConUnique 70--vecRepDataConKey, tupleRepDataConKey, sumRepDataConKey :: Unique-vecRepDataConKey                        = mkPreludeDataConUnique 71-tupleRepDataConKey                      = mkPreludeDataConUnique 72-sumRepDataConKey                        = mkPreludeDataConUnique 73---- See Note [Wiring in RuntimeRep] in TysWiredIn-runtimeRepSimpleDataConKeys, unliftedSimpleRepDataConKeys, unliftedRepDataConKeys :: [Unique]-liftedRepDataConKey :: Unique-runtimeRepSimpleDataConKeys@(liftedRepDataConKey : unliftedSimpleRepDataConKeys)-  = map mkPreludeDataConUnique [74..88]--unliftedRepDataConKeys = vecRepDataConKey :-                         tupleRepDataConKey :-                         sumRepDataConKey :-                         unliftedSimpleRepDataConKeys---- See Note [Wiring in RuntimeRep] in TysWiredIn--- VecCount-vecCountDataConKeys :: [Unique]-vecCountDataConKeys = map mkPreludeDataConUnique [89..94]---- See Note [Wiring in RuntimeRep] in TysWiredIn--- VecElem-vecElemDataConKeys :: [Unique]-vecElemDataConKeys = map mkPreludeDataConUnique [95..104]---- Typeable things-kindRepTyConAppDataConKey, kindRepVarDataConKey, kindRepAppDataConKey,-    kindRepFunDataConKey, kindRepTYPEDataConKey,-    kindRepTypeLitSDataConKey, kindRepTypeLitDDataConKey-    :: Unique-kindRepTyConAppDataConKey = mkPreludeDataConUnique 105-kindRepVarDataConKey      = mkPreludeDataConUnique 106-kindRepAppDataConKey      = mkPreludeDataConUnique 107-kindRepFunDataConKey      = mkPreludeDataConUnique 108-kindRepTYPEDataConKey     = mkPreludeDataConUnique 109-kindRepTypeLitSDataConKey = mkPreludeDataConUnique 110-kindRepTypeLitDDataConKey = mkPreludeDataConUnique 111--typeLitSymbolDataConKey, typeLitNatDataConKey :: Unique-typeLitSymbolDataConKey   = mkPreludeDataConUnique 112-typeLitNatDataConKey      = mkPreludeDataConUnique 113---- Unsafe equality-unsafeReflDataConKey :: Unique-unsafeReflDataConKey      = mkPreludeDataConUnique 114------------------ Template Haskell ----------------------      THNames.hs: USES DataUniques 200-250---------------------------------------------------------{--************************************************************************-*                                                                      *-\subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}-*                                                                      *-************************************************************************--}--wildCardKey, absentErrorIdKey, augmentIdKey, appendIdKey,-    buildIdKey, errorIdKey, foldrIdKey, recSelErrorIdKey,-    seqIdKey, eqStringIdKey,-    noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,-    runtimeErrorIdKey, patErrorIdKey, voidPrimIdKey,-    realWorldPrimIdKey, recConErrorIdKey,-    unpackCStringUtf8IdKey, unpackCStringAppendIdKey,-    unpackCStringFoldrIdKey, unpackCStringIdKey,-    typeErrorIdKey, divIntIdKey, modIntIdKey,-    absentSumFieldErrorIdKey :: Unique--wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard binders]-absentErrorIdKey              = mkPreludeMiscIdUnique  1-augmentIdKey                  = mkPreludeMiscIdUnique  2-appendIdKey                   = mkPreludeMiscIdUnique  3-buildIdKey                    = mkPreludeMiscIdUnique  4-errorIdKey                    = mkPreludeMiscIdUnique  5-foldrIdKey                    = mkPreludeMiscIdUnique  6-recSelErrorIdKey              = mkPreludeMiscIdUnique  7-seqIdKey                      = mkPreludeMiscIdUnique  8-absentSumFieldErrorIdKey      = mkPreludeMiscIdUnique  9-eqStringIdKey                 = mkPreludeMiscIdUnique 10-noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 11-nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 12-runtimeErrorIdKey             = mkPreludeMiscIdUnique 13-patErrorIdKey                 = mkPreludeMiscIdUnique 14-realWorldPrimIdKey            = mkPreludeMiscIdUnique 15-recConErrorIdKey              = mkPreludeMiscIdUnique 16-unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 17-unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 18-unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 19-unpackCStringIdKey            = mkPreludeMiscIdUnique 20-voidPrimIdKey                 = mkPreludeMiscIdUnique 21-typeErrorIdKey                = mkPreludeMiscIdUnique 22-divIntIdKey                   = mkPreludeMiscIdUnique 23-modIntIdKey                   = mkPreludeMiscIdUnique 24--concatIdKey, filterIdKey, zipIdKey,-    bindIOIdKey, returnIOIdKey, newStablePtrIdKey,-    printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,-    fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey :: Unique-concatIdKey                   = mkPreludeMiscIdUnique 31-filterIdKey                   = mkPreludeMiscIdUnique 32-zipIdKey                      = mkPreludeMiscIdUnique 33-bindIOIdKey                   = mkPreludeMiscIdUnique 34-returnIOIdKey                 = mkPreludeMiscIdUnique 35-newStablePtrIdKey             = mkPreludeMiscIdUnique 36-printIdKey                    = mkPreludeMiscIdUnique 37-failIOIdKey                   = mkPreludeMiscIdUnique 38-nullAddrIdKey                 = mkPreludeMiscIdUnique 39-voidArgIdKey                  = mkPreludeMiscIdUnique 40-fstIdKey                      = mkPreludeMiscIdUnique 41-sndIdKey                      = mkPreludeMiscIdUnique 42-otherwiseIdKey                = mkPreludeMiscIdUnique 43-assertIdKey                   = mkPreludeMiscIdUnique 44--mkIntegerIdKey, smallIntegerIdKey, wordToIntegerIdKey,-    integerToWordIdKey, integerToIntIdKey,-    integerToWord64IdKey, integerToInt64IdKey,-    word64ToIntegerIdKey, int64ToIntegerIdKey,-    plusIntegerIdKey, timesIntegerIdKey, minusIntegerIdKey,-    negateIntegerIdKey,-    eqIntegerPrimIdKey, neqIntegerPrimIdKey, absIntegerIdKey, signumIntegerIdKey,-    leIntegerPrimIdKey, gtIntegerPrimIdKey, ltIntegerPrimIdKey, geIntegerPrimIdKey,-    compareIntegerIdKey, quotRemIntegerIdKey, divModIntegerIdKey,-    quotIntegerIdKey, remIntegerIdKey, divIntegerIdKey, modIntegerIdKey,-    floatFromIntegerIdKey, doubleFromIntegerIdKey,-    encodeFloatIntegerIdKey, encodeDoubleIntegerIdKey,-    decodeDoubleIntegerIdKey,-    gcdIntegerIdKey, lcmIntegerIdKey,-    andIntegerIdKey, orIntegerIdKey, xorIntegerIdKey, complementIntegerIdKey,-    shiftLIntegerIdKey, shiftRIntegerIdKey :: Unique-mkIntegerIdKey                = mkPreludeMiscIdUnique 60-smallIntegerIdKey             = mkPreludeMiscIdUnique 61-integerToWordIdKey            = mkPreludeMiscIdUnique 62-integerToIntIdKey             = mkPreludeMiscIdUnique 63-integerToWord64IdKey          = mkPreludeMiscIdUnique 64-integerToInt64IdKey           = mkPreludeMiscIdUnique 65-plusIntegerIdKey              = mkPreludeMiscIdUnique 66-timesIntegerIdKey             = mkPreludeMiscIdUnique 67-minusIntegerIdKey             = mkPreludeMiscIdUnique 68-negateIntegerIdKey            = mkPreludeMiscIdUnique 69-eqIntegerPrimIdKey            = mkPreludeMiscIdUnique 70-neqIntegerPrimIdKey           = mkPreludeMiscIdUnique 71-absIntegerIdKey               = mkPreludeMiscIdUnique 72-signumIntegerIdKey            = mkPreludeMiscIdUnique 73-leIntegerPrimIdKey            = mkPreludeMiscIdUnique 74-gtIntegerPrimIdKey            = mkPreludeMiscIdUnique 75-ltIntegerPrimIdKey            = mkPreludeMiscIdUnique 76-geIntegerPrimIdKey            = mkPreludeMiscIdUnique 77-compareIntegerIdKey           = mkPreludeMiscIdUnique 78-quotIntegerIdKey              = mkPreludeMiscIdUnique 79-remIntegerIdKey               = mkPreludeMiscIdUnique 80-divIntegerIdKey               = mkPreludeMiscIdUnique 81-modIntegerIdKey               = mkPreludeMiscIdUnique 82-divModIntegerIdKey            = mkPreludeMiscIdUnique 83-quotRemIntegerIdKey           = mkPreludeMiscIdUnique 84-floatFromIntegerIdKey         = mkPreludeMiscIdUnique 85-doubleFromIntegerIdKey        = mkPreludeMiscIdUnique 86-encodeFloatIntegerIdKey       = mkPreludeMiscIdUnique 87-encodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 88-gcdIntegerIdKey               = mkPreludeMiscIdUnique 89-lcmIntegerIdKey               = mkPreludeMiscIdUnique 90-andIntegerIdKey               = mkPreludeMiscIdUnique 91-orIntegerIdKey                = mkPreludeMiscIdUnique 92-xorIntegerIdKey               = mkPreludeMiscIdUnique 93-complementIntegerIdKey        = mkPreludeMiscIdUnique 94-shiftLIntegerIdKey            = mkPreludeMiscIdUnique 95-shiftRIntegerIdKey            = mkPreludeMiscIdUnique 96-wordToIntegerIdKey            = mkPreludeMiscIdUnique 97-word64ToIntegerIdKey          = mkPreludeMiscIdUnique 98-int64ToIntegerIdKey           = mkPreludeMiscIdUnique 99-decodeDoubleIntegerIdKey      = mkPreludeMiscIdUnique 100--rootMainKey, runMainKey :: Unique-rootMainKey                   = mkPreludeMiscIdUnique 101-runMainKey                    = mkPreludeMiscIdUnique 102--thenIOIdKey, lazyIdKey, assertErrorIdKey, oneShotKey, runRWKey :: Unique-thenIOIdKey                   = mkPreludeMiscIdUnique 103-lazyIdKey                     = mkPreludeMiscIdUnique 104-assertErrorIdKey              = mkPreludeMiscIdUnique 105-oneShotKey                    = mkPreludeMiscIdUnique 106-runRWKey                      = mkPreludeMiscIdUnique 107--traceKey :: Unique-traceKey                      = mkPreludeMiscIdUnique 108--breakpointIdKey, breakpointCondIdKey :: Unique-breakpointIdKey               = mkPreludeMiscIdUnique 110-breakpointCondIdKey           = mkPreludeMiscIdUnique 111--inlineIdKey, noinlineIdKey :: Unique-inlineIdKey                   = mkPreludeMiscIdUnique 120--- see below--mapIdKey, groupWithIdKey, dollarIdKey :: Unique-mapIdKey              = mkPreludeMiscIdUnique 121-groupWithIdKey        = mkPreludeMiscIdUnique 122-dollarIdKey           = mkPreludeMiscIdUnique 123--coercionTokenIdKey :: Unique-coercionTokenIdKey    = mkPreludeMiscIdUnique 124--noinlineIdKey                 = mkPreludeMiscIdUnique 125--rationalToFloatIdKey, rationalToDoubleIdKey :: Unique-rationalToFloatIdKey   = mkPreludeMiscIdUnique 130-rationalToDoubleIdKey  = mkPreludeMiscIdUnique 131--magicDictKey :: Unique-magicDictKey                  = mkPreludeMiscIdUnique 156--coerceKey :: Unique-coerceKey                     = mkPreludeMiscIdUnique 157--{--Certain class operations from Prelude classes.  They get their own-uniques so we can look them up easily when we want to conjure them up-during type checking.--}---- Just a placeholder for unbound variables produced by the renamer:-unboundKey :: Unique-unboundKey                    = mkPreludeMiscIdUnique 158--fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,-    enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,-    enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,-    bindMClassOpKey, thenMClassOpKey, returnMClassOpKey, fmapClassOpKey-    :: Unique-fromIntegerClassOpKey         = mkPreludeMiscIdUnique 160-minusClassOpKey               = mkPreludeMiscIdUnique 161-fromRationalClassOpKey        = mkPreludeMiscIdUnique 162-enumFromClassOpKey            = mkPreludeMiscIdUnique 163-enumFromThenClassOpKey        = mkPreludeMiscIdUnique 164-enumFromToClassOpKey          = mkPreludeMiscIdUnique 165-enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 166-eqClassOpKey                  = mkPreludeMiscIdUnique 167-geClassOpKey                  = mkPreludeMiscIdUnique 168-negateClassOpKey              = mkPreludeMiscIdUnique 169-bindMClassOpKey               = mkPreludeMiscIdUnique 171 -- (>>=)-thenMClassOpKey               = mkPreludeMiscIdUnique 172 -- (>>)-fmapClassOpKey                = mkPreludeMiscIdUnique 173-returnMClassOpKey             = mkPreludeMiscIdUnique 174---- Recursive do notation-mfixIdKey :: Unique-mfixIdKey       = mkPreludeMiscIdUnique 175---- MonadFail operations-failMClassOpKey :: Unique-failMClassOpKey = mkPreludeMiscIdUnique 176---- Arrow notation-arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,-    loopAIdKey :: Unique-arrAIdKey       = mkPreludeMiscIdUnique 180-composeAIdKey   = mkPreludeMiscIdUnique 181 -- >>>-firstAIdKey     = mkPreludeMiscIdUnique 182-appAIdKey       = mkPreludeMiscIdUnique 183-choiceAIdKey    = mkPreludeMiscIdUnique 184 --  |||-loopAIdKey      = mkPreludeMiscIdUnique 185--fromStringClassOpKey :: Unique-fromStringClassOpKey          = mkPreludeMiscIdUnique 186---- Annotation type checking-toAnnotationWrapperIdKey :: Unique-toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 187---- Conversion functions-fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique-fromIntegralIdKey    = mkPreludeMiscIdUnique 190-realToFracIdKey      = mkPreludeMiscIdUnique 191-toIntegerClassOpKey  = mkPreludeMiscIdUnique 192-toRationalClassOpKey = mkPreludeMiscIdUnique 193---- Monad comprehensions-guardMIdKey, liftMIdKey, mzipIdKey :: Unique-guardMIdKey     = mkPreludeMiscIdUnique 194-liftMIdKey      = mkPreludeMiscIdUnique 195-mzipIdKey       = mkPreludeMiscIdUnique 196---- GHCi-ghciStepIoMClassOpKey :: Unique-ghciStepIoMClassOpKey = mkPreludeMiscIdUnique 197---- Overloaded lists-isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: Unique-isListClassKey = mkPreludeMiscIdUnique 198-fromListClassOpKey = mkPreludeMiscIdUnique 199-fromListNClassOpKey = mkPreludeMiscIdUnique 500-toListClassOpKey = mkPreludeMiscIdUnique 501--proxyHashKey :: Unique-proxyHashKey = mkPreludeMiscIdUnique 502------------------ Template Haskell ----------------------      THNames.hs: USES IdUniques 200-499---------------------------------------------------------- Used to make `Typeable` dictionaries-mkTyConKey-  , mkTrTypeKey-  , mkTrConKey-  , mkTrAppKey-  , mkTrFunKey-  , typeNatTypeRepKey-  , typeSymbolTypeRepKey-  , typeRepIdKey-  :: Unique-mkTyConKey            = mkPreludeMiscIdUnique 503-mkTrTypeKey           = mkPreludeMiscIdUnique 504-mkTrConKey            = mkPreludeMiscIdUnique 505-mkTrAppKey            = mkPreludeMiscIdUnique 506-typeNatTypeRepKey     = mkPreludeMiscIdUnique 507-typeSymbolTypeRepKey  = mkPreludeMiscIdUnique 508-typeRepIdKey          = mkPreludeMiscIdUnique 509-mkTrFunKey            = mkPreludeMiscIdUnique 510---- Representations for primitive types-trTYPEKey-  ,trTYPE'PtrRepLiftedKey-  , trRuntimeRepKey-  , tr'PtrRepLiftedKey-  :: Unique-trTYPEKey              = mkPreludeMiscIdUnique 511-trTYPE'PtrRepLiftedKey = mkPreludeMiscIdUnique 512-trRuntimeRepKey        = mkPreludeMiscIdUnique 513-tr'PtrRepLiftedKey     = mkPreludeMiscIdUnique 514---- KindReps for common cases-starKindRepKey, starArrStarKindRepKey, starArrStarArrStarKindRepKey :: Unique-starKindRepKey        = mkPreludeMiscIdUnique 520-starArrStarKindRepKey = mkPreludeMiscIdUnique 521-starArrStarArrStarKindRepKey = mkPreludeMiscIdUnique 522---- Dynamic-toDynIdKey :: Unique-toDynIdKey            = mkPreludeMiscIdUnique 523---bitIntegerIdKey :: Unique-bitIntegerIdKey       = mkPreludeMiscIdUnique 550--heqSCSelIdKey, eqSCSelIdKey, coercibleSCSelIdKey :: Unique-eqSCSelIdKey        = mkPreludeMiscIdUnique 551-heqSCSelIdKey       = mkPreludeMiscIdUnique 552-coercibleSCSelIdKey = mkPreludeMiscIdUnique 553--sappendClassOpKey :: Unique-sappendClassOpKey = mkPreludeMiscIdUnique 554--memptyClassOpKey, mappendClassOpKey, mconcatClassOpKey :: Unique-memptyClassOpKey  = mkPreludeMiscIdUnique 555-mappendClassOpKey = mkPreludeMiscIdUnique 556-mconcatClassOpKey = mkPreludeMiscIdUnique 557--emptyCallStackKey, pushCallStackKey :: Unique-emptyCallStackKey = mkPreludeMiscIdUnique 558-pushCallStackKey  = mkPreludeMiscIdUnique 559--fromStaticPtrClassOpKey :: Unique-fromStaticPtrClassOpKey = mkPreludeMiscIdUnique 560--makeStaticKey :: Unique-makeStaticKey = mkPreludeMiscIdUnique 561---- Natural-naturalFromIntegerIdKey, naturalToIntegerIdKey, plusNaturalIdKey,-   minusNaturalIdKey, timesNaturalIdKey, mkNaturalIdKey,-   naturalSDataConKey, wordToNaturalIdKey :: Unique-naturalFromIntegerIdKey = mkPreludeMiscIdUnique 562-naturalToIntegerIdKey   = mkPreludeMiscIdUnique 563-plusNaturalIdKey        = mkPreludeMiscIdUnique 564-minusNaturalIdKey       = mkPreludeMiscIdUnique 565-timesNaturalIdKey       = mkPreludeMiscIdUnique 566-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--{--************************************************************************-*                                                                      *-\subsection[Class-std-groups]{Standard groups of Prelude classes}-*                                                                      *-************************************************************************--NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@-even though every numeric class has these two as a superclass,-because the list of ambiguous dictionaries hasn't been simplified.--}--numericClassKeys :: [Unique]-numericClassKeys =-        [ numClassKey-        , realClassKey-        , integralClassKey-        ]-        ++ fractionalClassKeys--fractionalClassKeys :: [Unique]-fractionalClassKeys =-        [ fractionalClassKey-        , floatingClassKey-        , realFracClassKey-        , realFloatClassKey-        ]---- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),--- and are: "classes defined in the Prelude or a standard library"-standardClassKeys :: [Unique]-standardClassKeys = derivableClassKeys ++ numericClassKeys-                  ++ [randomClassKey, randomGenClassKey,-                      functorClassKey,-                      monadClassKey, monadPlusClassKey, monadFailClassKey,-                      semigroupClassKey, monoidClassKey,-                      isStringClassKey,-                      applicativeClassKey, foldableClassKey,-                      traversableClassKey, alternativeClassKey-                     ]--{--@derivableClassKeys@ is also used in checking \tr{deriving} constructs-(@TcDeriv@).--}--derivableClassKeys :: [Unique]-derivableClassKeys-  = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,-      boundedClassKey, showClassKey, readClassKey ]----- These are the "interactive classes" that are consulted when doing--- defaulting. Does not include Num or IsString, which have special--- handling.-interactiveClassNames :: [Name]-interactiveClassNames-  = [ showClassName, eqClassName, ordClassName, foldableClassName-    , traversableClassName ]--interactiveClassKeys :: [Unique]-interactiveClassKeys = map getUnique interactiveClassNames--{--************************************************************************-*                                                                      *-   Semi-builtin names-*                                                                      *-************************************************************************--The following names should be considered by GHCi to be in scope always.---}--pretendNameIsInScope :: Name -> Bool-pretendNameIsInScope n-  = any (n `hasKey`)-    [ liftedTypeKindTyConKey, tYPETyConKey-    , runtimeRepTyConKey, liftedRepDataConKey ]
− compiler/prelude/PrelNames.hs-boot 
@@ -1,7 +0,0 @@-module PrelNames where--import GHC.Types.Module-import GHC.Types.Unique--mAIN :: Module-liftedTypeKindTyConKey :: Unique
− compiler/prelude/PrimOp.hs 
@@ -1,698 +0,0 @@-{--(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[PrimOp]{Primitive operations (machine-level)}--}--{-# LANGUAGE CPP #-}--module PrimOp (-        PrimOp(..), PrimOpVecCat(..), allThePrimOps,-        primOpType, primOpSig,-        primOpTag, maxPrimOpTag, primOpOcc,-        primOpWrapperId,--        tagToEnumKey,--        primOpOutOfLine, primOpCodeSize,-        primOpOkForSpeculation, primOpOkForSideEffects,-        primOpIsCheap, primOpFixity,--        getPrimOpResultInfo,  isComparisonPrimOp, PrimOpResultInfo(..),--        PrimCall(..)-    ) where--#include "HsVersions.h"--import GhcPrelude--import TysPrim-import TysWiredIn--import GHC.Cmm.Type-import GHC.Types.Demand-import GHC.Types.Id      ( Id, mkVanillaGlobalWithInfo )-import GHC.Types.Id.Info ( vanillaIdInfo, setCafInfo, CafInfo(NoCafRefs) )-import GHC.Types.Name-import PrelNames         ( gHC_PRIMOPWRAPPERS )-import GHC.Core.TyCon    ( TyCon, isPrimTyCon, PrimRep(..) )-import GHC.Core.Type-import GHC.Types.RepType ( typePrimRep1, tyConPrimRep1 )-import GHC.Types.Basic   ( Arity, Fixity(..), FixityDirection(..), Boxity(..),-                           SourceText(..) )-import GHC.Types.SrcLoc  ( wiredInSrcSpan )-import GHC.Types.ForeignCall ( CLabelString )-import GHC.Types.Unique  ( Unique, mkPrimOpIdUnique, mkPrimOpWrapperUnique )-import GHC.Types.Module  ( UnitId )-import Outputable-import FastString--{--************************************************************************-*                                                                      *-\subsection[PrimOp-datatype]{Datatype for @PrimOp@ (an enumeration)}-*                                                                      *-************************************************************************--These are in \tr{state-interface.verb} order.--}---- supplies:--- data PrimOp = ...-#include "primop-data-decl.hs-incl"---- supplies--- primOpTag :: PrimOp -> Int-#include "primop-tag.hs-incl"-primOpTag _ = error "primOpTag: unknown primop"---instance Eq PrimOp where-    op1 == op2 = primOpTag op1 == primOpTag op2--instance Ord PrimOp where-    op1 <  op2 =  primOpTag op1 < primOpTag op2-    op1 <= op2 =  primOpTag op1 <= primOpTag op2-    op1 >= op2 =  primOpTag op1 >= primOpTag op2-    op1 >  op2 =  primOpTag op1 > primOpTag op2-    op1 `compare` op2 | op1 < op2  = LT-                      | op1 == op2 = EQ-                      | otherwise  = GT--instance Outputable PrimOp where-    ppr op = pprPrimOp op--data PrimOpVecCat = IntVec-                  | WordVec-                  | FloatVec---- An @Enum@-derived list would be better; meanwhile... (ToDo)--allThePrimOps :: [PrimOp]-allThePrimOps =-#include "primop-list.hs-incl"--tagToEnumKey :: Unique-tagToEnumKey = mkPrimOpIdUnique (primOpTag TagToEnumOp)--{--************************************************************************-*                                                                      *-\subsection[PrimOp-info]{The essential info about each @PrimOp@}-*                                                                      *-************************************************************************--The @String@ in the @PrimOpInfos@ is the ``base name'' by which the user may-refer to the primitive operation.  The conventional \tr{#}-for--unboxed ops is added on later.--The reason for the funny characters in the names is so we do not-interfere with the programmer's Haskell name spaces.--We use @PrimKinds@ for the ``type'' information, because they're-(slightly) more convenient to use than @TyCons@.--}--data PrimOpInfo-  = Dyadic      OccName         -- string :: T -> T -> T-                Type-  | Monadic     OccName         -- string :: T -> T-                Type-  | Compare     OccName         -- string :: T -> T -> Int#-                Type-  | GenPrimOp   OccName         -- string :: \/a1..an . T1 -> .. -> Tk -> T-                [TyVar]-                [Type]-                Type--mkDyadic, mkMonadic, mkCompare :: FastString -> Type -> PrimOpInfo-mkDyadic str  ty = Dyadic  (mkVarOccFS str) ty-mkMonadic str ty = Monadic (mkVarOccFS str) ty-mkCompare str ty = Compare (mkVarOccFS str) ty--mkGenPrimOp :: FastString -> [TyVar] -> [Type] -> Type -> PrimOpInfo-mkGenPrimOp str tvs tys ty = GenPrimOp (mkVarOccFS str) tvs tys ty--{--************************************************************************-*                                                                      *-\subsubsection{Strictness}-*                                                                      *-************************************************************************--Not all primops are strict!--}--primOpStrictness :: PrimOp -> Arity -> StrictSig-        -- See Demand.StrictnessInfo for discussion of what the results-        -- The arity should be the arity of the primop; that's why-        -- this function isn't exported.-#include "primop-strictness.hs-incl"--{--************************************************************************-*                                                                      *-\subsubsection{Fixity}-*                                                                      *-************************************************************************--}--primOpFixity :: PrimOp -> Maybe Fixity-#include "primop-fixity.hs-incl"--{--************************************************************************-*                                                                      *-\subsubsection[PrimOp-comparison]{PrimOpInfo basic comparison ops}-*                                                                      *-************************************************************************--@primOpInfo@ gives all essential information (from which everything-else, notably a type, can be constructed) for each @PrimOp@.--}--primOpInfo :: PrimOp -> PrimOpInfo-#include "primop-primop-info.hs-incl"-primOpInfo _ = error "primOpInfo: unknown primop"--{--Here are a load of comments from the old primOp info:--A @Word#@ is an unsigned @Int#@.--@decodeFloat#@ is given w/ Integer-stuff (it's similar).--@decodeDouble#@ is given w/ Integer-stuff (it's similar).--Decoding of floating-point numbers is sorta Integer-related.  Encoding-is done with plain ccalls now (see PrelNumExtra.hs).--A @Weak@ Pointer is created by the @mkWeak#@ primitive:--        mkWeak# :: k -> v -> f -> State# RealWorld-                        -> (# State# RealWorld, Weak# v #)--In practice, you'll use the higher-level--        data Weak v = Weak# v-        mkWeak :: k -> v -> IO () -> IO (Weak v)--The following operation dereferences a weak pointer.  The weak pointer-may have been finalized, so the operation returns a result code which-must be inspected before looking at the dereferenced value.--        deRefWeak# :: Weak# v -> State# RealWorld ->-                        (# State# RealWorld, v, Int# #)--Only look at v if the Int# returned is /= 0 !!--The higher-level op is--        deRefWeak :: Weak v -> IO (Maybe v)--Weak pointers can be finalized early by using the finalize# operation:--        finalizeWeak# :: Weak# v -> State# RealWorld ->-                           (# State# RealWorld, Int#, IO () #)--The Int# returned is either--        0 if the weak pointer has already been finalized, or it has no-          finalizer (the third component is then invalid).--        1 if the weak pointer is still alive, with the finalizer returned-          as the third component.--A {\em stable name/pointer} is an index into a table of stable name-entries.  Since the garbage collector is told about stable pointers,-it is safe to pass a stable pointer to external systems such as C-routines.--\begin{verbatim}-makeStablePtr#  :: a -> State# RealWorld -> (# State# RealWorld, StablePtr# a #)-freeStablePtr   :: StablePtr# a -> State# RealWorld -> State# RealWorld-deRefStablePtr# :: StablePtr# a -> State# RealWorld -> (# State# RealWorld, a #)-eqStablePtr#    :: StablePtr# a -> StablePtr# a -> Int#-\end{verbatim}--It may seem a bit surprising that @makeStablePtr#@ is a @IO@-operation since it doesn't (directly) involve IO operations.  The-reason is that if some optimisation pass decided to duplicate calls to-@makeStablePtr#@ and we only pass one of the stable pointers over, a-massive space leak can result.  Putting it into the IO monad-prevents this.  (Another reason for putting them in a monad is to-ensure correct sequencing wrt the side-effecting @freeStablePtr@-operation.)--An important property of stable pointers is that if you call-makeStablePtr# twice on the same object you get the same stable-pointer back.--Note that we can implement @freeStablePtr#@ using @_ccall_@ (and,-besides, it's not likely to be used from Haskell) so it's not a-primop.--Question: Why @RealWorld@ - won't any instance of @_ST@ do the job? [ADR]--Stable Names-~~~~~~~~~~~~--A stable name is like a stable pointer, but with three important differences:--        (a) You can't deRef one to get back to the original object.-        (b) You can convert one to an Int.-        (c) You don't need to 'freeStableName'--The existence of a stable name doesn't guarantee to keep the object it-points to alive (unlike a stable pointer), hence (a).--Invariants:--        (a) makeStableName always returns the same value for a given-            object (same as stable pointers).--        (b) if two stable names are equal, it implies that the objects-            from which they were created were the same.--        (c) stableNameToInt always returns the same Int for a given-            stable name.---These primops are pretty weird.--        tagToEnum# :: Int -> a    (result type must be an enumerated type)--The constraints aren't currently checked by the front end, but the-code generator will fall over if they aren't satisfied.--************************************************************************-*                                                                      *-            Which PrimOps are out-of-line-*                                                                      *-************************************************************************--Some PrimOps need to be called out-of-line because they either need to-perform a heap check or they block.--}--primOpOutOfLine :: PrimOp -> Bool-#include "primop-out-of-line.hs-incl"--{--************************************************************************-*                                                                      *-            Failure and side effects-*                                                                      *-************************************************************************--Note [Checking versus non-checking primops]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--  In GHC primops break down into two classes:--   a. Checking primops behave, for instance, like division. In this-      case the primop may throw an exception (e.g. division-by-zero)-      and is consequently is marked with the can_fail flag described below.-      The ability to fail comes at the expense of precluding some optimizations.--   b. Non-checking primops behavior, for instance, like addition. While-      addition can overflow it does not produce an exception. So can_fail is-      set to False, and we get more optimisation opportunities.  But we must-      never throw an exception, so we cannot rewrite to a call to error.--  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 [Core let/app invariant] in GHC.Core) which is critical to-  the simplifier's ability to float without fear of changing program meaning.---Note [PrimOp can_fail and has_side_effects]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Both can_fail and has_side_effects mean that the primop has-some effect that is not captured entirely by its result value.------------  has_side_effects ----------------------A primop "has_side_effects" if it has some *write* effect, visible-elsewhere-    - writing to the world (I/O)-    - writing to a mutable data structure (writeIORef)-    - throwing a synchronous Haskell exception--Often such primops have a type like-   State -> input -> (State, output)-so the state token guarantees ordering.  In general we rely *only* on-data dependencies of the state token to enforce write-effect ordering-- * NB1: if you inline unsafePerformIO, you may end up with-   side-effecting ops whose 'state' output is discarded.-   And programmers may do that by hand; see #9390.-   That is why we (conservatively) do not discard write-effecting-   primops even if both their state and result is discarded.-- * NB2: We consider primops, such as raiseIO#, that can raise a-   (Haskell) synchronous exception to "have_side_effects" but not-   "can_fail".  We must be careful about not discarding such things;-   see the paper "A semantics for imprecise exceptions".-- * NB3: *Read* effects (like reading an IORef) don't count here,-   because it doesn't matter if we don't do them, or do them more than-   once.  *Sequencing* is maintained by the data dependency of the state-   token.------------  can_fail -----------------------------A primop "can_fail" if it can fail with an *unchecked* exception on-some elements of its input domain. Main examples:-   division (fails on zero denominator)-   array indexing (fails if the index is out of bounds)--An "unchecked exception" is one that is an outright error, (not-turned into a Haskell exception,) such as seg-fault or-divide-by-zero error.  Such can_fail primops are ALWAYS surrounded-with a test that checks for the bad cases, but we need to be-very careful about code motion that might move it out of-the scope of the test.--Note [Transformations affected by can_fail and has_side_effects]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The can_fail and has_side_effects properties have the following effect-on program transformations.  Summary table is followed by details.--            can_fail     has_side_effects-Discard        YES           NO-Float in       YES           YES-Float out      NO            NO-Duplicate      YES           NO--* Discarding.   case (a `op` b) of _ -> rhs  ===>   rhs-  You should not discard a has_side_effects primop; e.g.-     case (writeIntArray# a i v s of (# _, _ #) -> True-  Arguably you should be able to discard this, since the-  returned stat token is not used, but that relies on NEVER-  inlining unsafePerformIO, and programmers sometimes write-  this kind of stuff by hand (#9390).  So we (conservatively)-  never discard a has_side_effects primop.--  However, it's fine to discard a can_fail primop.  For example-     case (indexIntArray# a i) of _ -> True-  We can discard indexIntArray#; it has can_fail, but not-  has_side_effects; see #5658 which was all about this.-  Notice that indexIntArray# is (in a more general handling of-  effects) read effect, but we don't care about that here, and-  treat read effects as *not* has_side_effects.--  Similarly (a `/#` b) can be discarded.  It can seg-fault or-  cause a hardware exception, but not a synchronous Haskell-  exception.----  Synchronous Haskell exceptions, e.g. from raiseIO#, are treated-  as has_side_effects and hence are not discarded.--* Float in.  You can float a can_fail or has_side_effects primop-  *inwards*, but not inside a lambda (see Duplication below).--* Float out.  You must not float a can_fail primop *outwards* lest-  you escape the dynamic scope of the test.  Example:-      case d ># 0# of-        True  -> case x /# d of r -> r +# 1-        False -> 0-  Here we must not float the case outwards to give-      case x/# d of r ->-      case d ># 0# of-        True  -> r +# 1-        False -> 0--  Nor can you float out a has_side_effects primop.  For example:-       if blah then case writeMutVar# v True s0 of (# s1 #) -> s1-               else s0-  Notice that s0 is mentioned in both branches of the 'if', but-  only one of these two will actually be consumed.  But if we-  float out to-      case writeMutVar# v True s0 of (# s1 #) ->-      if blah then s1 else s0-  the writeMutVar will be performed in both branches, which is-  utterly wrong.--* Duplication.  You cannot duplicate a has_side_effect primop.  You-  might wonder how this can occur given the state token threading, but-  just look at Control.Monad.ST.Lazy.Imp.strictToLazy!  We get-  something like this-        p = case readMutVar# s v of-              (# s', r #) -> (S# s', r)-        s' = case p of (s', r) -> s'-        r  = case p of (s', r) -> r--  (All these bindings are boxed.)  If we inline p at its two call-  sites, we get a catastrophe: because the read is performed once when-  s' is demanded, and once when 'r' is demanded, which may be much-  later.  Utterly wrong.  #3207 is real example of this happening.--  However, it's fine to duplicate a can_fail primop.  That is really-  the only difference between can_fail and has_side_effects.--Note [Implementation: how can_fail/has_side_effects affect transformations]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-How do we ensure that that floating/duplication/discarding are done right-in the simplifier?--Two main predicates on primpops test these flags:-  primOpOkForSideEffects <=> not has_side_effects-  primOpOkForSpeculation <=> not (has_side_effects || can_fail)--  * The "no-float-out" thing is achieved by ensuring that we never-    let-bind a can_fail or has_side_effects primop.  The RHS of a-    let-binding (which can float in and out freely) satisfies-    exprOkForSpeculation; this is the let/app invariant.  And-    exprOkForSpeculation is false of can_fail and has_side_effects.--  * So can_fail and has_side_effects primops will appear only as the-    scrutinees of cases, and that's why the FloatIn pass is capable-    of floating case bindings inwards.--  * The no-duplicate thing is done via primOpIsCheap, by making-    has_side_effects things (very very very) not-cheap!--}--primOpHasSideEffects :: PrimOp -> Bool-#include "primop-has-side-effects.hs-incl"--primOpCanFail :: PrimOp -> Bool-#include "primop-can-fail.hs-incl"--primOpOkForSpeculation :: PrimOp -> Bool-  -- See Note [PrimOp can_fail and has_side_effects]-  -- See comments with GHC.Core.Utils.exprOkForSpeculation-  -- primOpOkForSpeculation => primOpOkForSideEffects-primOpOkForSpeculation op-  =  primOpOkForSideEffects op-  && not (primOpOutOfLine op || primOpCanFail op)-    -- I think the "out of line" test is because out of line things can-    -- be expensive (eg sine, cosine), and so we may not want to speculate them--primOpOkForSideEffects :: PrimOp -> Bool-primOpOkForSideEffects op-  = not (primOpHasSideEffects op)--{--Note [primOpIsCheap]-~~~~~~~~~~~~~~~~~~~~--@primOpIsCheap@, as used in GHC.Core.Op.Simplify.Utils.  For now (HACK-WARNING), we just borrow some other predicates for a-what-should-be-good-enough test.  "Cheap" means willing to call it more-than once, and/or push it inside a lambda.  The latter could change the-behaviour of 'seq' for primops that can fail, so we don't treat them as cheap.--}--primOpIsCheap :: PrimOp -> Bool--- See Note [PrimOp can_fail and has_side_effects]-primOpIsCheap op = primOpOkForSpeculation op--- In March 2001, we changed this to---      primOpIsCheap op = False--- thereby making *no* primops seem cheap.  But this killed eta--- expansion on case (x ==# y) of True -> \s -> ...--- which is bad.  In particular a loop like---      doLoop n = loop 0---     where---         loop i | i == n    = return ()---                | otherwise = bar i >> loop (i+1)--- allocated a closure every time round because it doesn't eta expand.------ The problem that originally gave rise to the change was---      let x = a +# b *# c in x +# x--- were we don't want to inline x. But primopIsCheap doesn't control--- that (it's exprIsDupable that does) so the problem doesn't occur--- even if primOpIsCheap sometimes says 'True'.--{--************************************************************************-*                                                                      *-               PrimOp code size-*                                                                      *-************************************************************************--primOpCodeSize-~~~~~~~~~~~~~~-Gives an indication of the code size of a primop, for the purposes of-calculating unfolding sizes; see GHC.Core.Unfold.sizeExpr.--}--primOpCodeSize :: PrimOp -> Int-#include "primop-code-size.hs-incl"--primOpCodeSizeDefault :: Int-primOpCodeSizeDefault = 1-  -- GHC.Core.Unfold.primOpSize already takes into account primOpOutOfLine-  -- and adds some further costs for the args in that case.--primOpCodeSizeForeignCall :: Int-primOpCodeSizeForeignCall = 4--{--************************************************************************-*                                                                      *-               PrimOp types-*                                                                      *-************************************************************************--}--primOpType :: PrimOp -> Type  -- you may want to use primOpSig instead-primOpType op-  = case primOpInfo op of-    Dyadic  _occ ty -> dyadic_fun_ty ty-    Monadic _occ ty -> monadic_fun_ty ty-    Compare _occ ty -> compare_fun_ty ty--    GenPrimOp _occ tyvars arg_tys res_ty ->-        mkSpecForAllTys tyvars (mkVisFunTys arg_tys res_ty)--primOpOcc :: PrimOp -> OccName-primOpOcc op = case primOpInfo op of-               Dyadic    occ _     -> occ-               Monadic   occ _     -> occ-               Compare   occ _     -> occ-               GenPrimOp occ _ _ _ -> occ--{- Note [Primop wrappers]-~~~~~~~~~~~~~~~~~~~~~~~~~-Previously hasNoBinding would claim that PrimOpIds didn't have a curried-function definition. This caused quite some trouble as we would be forced to-eta expand unsaturated primop applications very late in the Core pipeline. Not-only would this produce unnecessary thunks, but it would also result in nasty-inconsistencies in CAFfy-ness determinations (see #16846 and-Note [CAFfyness inconsistencies due to late eta expansion] in GHC.Iface.Tidy).--However, it was quite unnecessary for hasNoBinding to claim this; primops in-fact *do* have curried definitions which are found in GHC.PrimopWrappers, which-is auto-generated by utils/genprimops from prelude/primops.txt.pp. These wrappers-are standard Haskell functions mirroring the types of the primops they wrap.-For instance, in the case of plusInt# we would have:--    module GHC.PrimopWrappers where-    import GHC.Prim as P-    plusInt# a b = P.plusInt# a b--We now take advantage of these curried definitions by letting hasNoBinding-claim that PrimOpIds have a curried definition and then rewrite any unsaturated-PrimOpId applications that we find during CoreToStg as applications of the-associated wrapper (e.g. `GHC.Prim.plusInt# 3#` will get rewritten to-`GHC.PrimopWrappers.plusInt# 3#`).` The Id of the wrapper for a primop can be-found using 'PrimOp.primOpWrapperId'.--Nota Bene: GHC.PrimopWrappers is needed *regardless*, because it's-used by GHCi, which does not implement primops direct at all.---}---- | Returns the 'Id' of the wrapper associated with the given 'PrimOp'.--- See Note [Primop wrappers].-primOpWrapperId :: PrimOp -> Id-primOpWrapperId op = mkVanillaGlobalWithInfo name ty info-  where-    info = setCafInfo vanillaIdInfo NoCafRefs-    name = mkExternalName uniq gHC_PRIMOPWRAPPERS (primOpOcc op) wiredInSrcSpan-    uniq = mkPrimOpWrapperUnique (primOpTag op)-    ty   = primOpType op--isComparisonPrimOp :: PrimOp -> Bool-isComparisonPrimOp op = case primOpInfo op of-                          Compare {} -> True-                          _          -> False---- primOpSig is like primOpType but gives the result split apart:--- (type variables, argument types, result type)--- It also gives arity, strictness info--primOpSig :: PrimOp -> ([TyVar], [Type], Type, Arity, StrictSig)-primOpSig op-  = (tyvars, arg_tys, res_ty, arity, primOpStrictness op arity)-  where-    arity = length arg_tys-    (tyvars, arg_tys, res_ty)-      = case (primOpInfo op) of-        Monadic   _occ ty                    -> ([],     [ty],    ty       )-        Dyadic    _occ ty                    -> ([],     [ty,ty], ty       )-        Compare   _occ ty                    -> ([],     [ty,ty], intPrimTy)-        GenPrimOp _occ tyvars arg_tys res_ty -> (tyvars, arg_tys, res_ty   )--data PrimOpResultInfo-  = ReturnsPrim     PrimRep-  | ReturnsAlg      TyCon---- Some PrimOps need not return a manifest primitive or algebraic value--- (i.e. they might return a polymorphic value).  These PrimOps *must*--- be out of line, or the code generator won't work.--getPrimOpResultInfo :: PrimOp -> PrimOpResultInfo-getPrimOpResultInfo op-  = case (primOpInfo op) of-      Dyadic  _ ty                        -> ReturnsPrim (typePrimRep1 ty)-      Monadic _ ty                        -> ReturnsPrim (typePrimRep1 ty)-      Compare _ _                         -> ReturnsPrim (tyConPrimRep1 intPrimTyCon)-      GenPrimOp _ _ _ ty | isPrimTyCon tc -> ReturnsPrim (tyConPrimRep1 tc)-                         | otherwise      -> ReturnsAlg tc-                         where-                           tc = tyConAppTyCon ty-                        -- All primops return a tycon-app result-                        -- The tycon can be an unboxed tuple or sum, though,-                        -- which gives rise to a ReturnAlg--{--We do not currently make use of whether primops are commutable.--We used to try to move constants to the right hand side for strength-reduction.--}--{--commutableOp :: PrimOp -> Bool-#include "primop-commutable.hs-incl"--}---- Utils:--dyadic_fun_ty, monadic_fun_ty, compare_fun_ty :: Type -> Type-dyadic_fun_ty  ty = mkVisFunTys [ty, ty] ty-monadic_fun_ty ty = mkVisFunTy  ty ty-compare_fun_ty ty = mkVisFunTys [ty, ty] intPrimTy---- Output stuff:--pprPrimOp  :: PrimOp -> SDoc-pprPrimOp other_op = pprOccName (primOpOcc other_op)--{--************************************************************************-*                                                                      *-\subsubsection[PrimCall]{User-imported primitive calls}-*                                                                      *-************************************************************************--}--data PrimCall = PrimCall CLabelString UnitId--instance Outputable PrimCall where-  ppr (PrimCall lbl pkgId)-        = text "__primcall" <+> ppr pkgId <+> ppr lbl
− compiler/prelude/PrimOp.hs-boot 
@@ -1,5 +0,0 @@-module PrimOp where--import GhcPrelude ()--data PrimOp
− compiler/prelude/TysPrim.hs 
@@ -1,1110 +0,0 @@-{--(c) The AQUA Project, Glasgow University, 1994-1998---\section[TysPrim]{Wired-in knowledge about primitive types}--}--{-# LANGUAGE CPP #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}---- | This module defines TyCons that can't be expressed in Haskell.---   They are all, therefore, wired-in TyCons.  C.f module TysWiredIn-module TysPrim(-        mkPrimTyConName, -- For implicit parameters in TysWiredIn only--        mkTemplateKindVars, mkTemplateTyVars, mkTemplateTyVarsFrom,-        mkTemplateKiTyVars, mkTemplateKiTyVar,--        mkTemplateTyConBinders, mkTemplateKindTyConBinders,-        mkTemplateAnonTyConBinders,--        alphaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,-        alphaTys, alphaTy, betaTy, gammaTy, deltaTy,-        alphaTyVarsUnliftedRep, alphaTyVarUnliftedRep,-        alphaTysUnliftedRep, alphaTyUnliftedRep,-        runtimeRep1TyVar, runtimeRep2TyVar, runtimeRep1Ty, runtimeRep2Ty,-        openAlphaTy, openBetaTy, openAlphaTyVar, openBetaTyVar,--        -- Kind constructors...-        tYPETyCon, tYPETyConName,--        -- Kinds-        tYPE, primRepToRuntimeRep,--        funTyCon, funTyConName,-        unexposedPrimTyCons, exposedPrimTyCons, primTyCons,--        charPrimTyCon,          charPrimTy, charPrimTyConName,-        intPrimTyCon,           intPrimTy, intPrimTyConName,-        wordPrimTyCon,          wordPrimTy, wordPrimTyConName,-        addrPrimTyCon,          addrPrimTy, addrPrimTyConName,-        floatPrimTyCon,         floatPrimTy, floatPrimTyConName,-        doublePrimTyCon,        doublePrimTy, doublePrimTyConName,--        voidPrimTyCon,          voidPrimTy,-        statePrimTyCon,         mkStatePrimTy,-        realWorldTyCon,         realWorldTy, realWorldStatePrimTy,--        proxyPrimTyCon,         mkProxyPrimTy,--        arrayPrimTyCon, mkArrayPrimTy,-        byteArrayPrimTyCon,     byteArrayPrimTy,-        arrayArrayPrimTyCon, mkArrayArrayPrimTy,-        smallArrayPrimTyCon, mkSmallArrayPrimTy,-        mutableArrayPrimTyCon, mkMutableArrayPrimTy,-        mutableByteArrayPrimTyCon, mkMutableByteArrayPrimTy,-        mutableArrayArrayPrimTyCon, mkMutableArrayArrayPrimTy,-        smallMutableArrayPrimTyCon, mkSmallMutableArrayPrimTy,-        mutVarPrimTyCon, mkMutVarPrimTy,--        mVarPrimTyCon,                  mkMVarPrimTy,-        tVarPrimTyCon,                  mkTVarPrimTy,-        stablePtrPrimTyCon,             mkStablePtrPrimTy,-        stableNamePrimTyCon,            mkStableNamePrimTy,-        compactPrimTyCon,               compactPrimTy,-        bcoPrimTyCon,                   bcoPrimTy,-        weakPrimTyCon,                  mkWeakPrimTy,-        threadIdPrimTyCon,              threadIdPrimTy,--        int8PrimTyCon,          int8PrimTy, int8PrimTyConName,-        word8PrimTyCon,         word8PrimTy, word8PrimTyConName,--        int16PrimTyCon,         int16PrimTy, int16PrimTyConName,-        word16PrimTyCon,        word16PrimTy, word16PrimTyConName,--        int32PrimTyCon,         int32PrimTy, int32PrimTyConName,-        word32PrimTyCon,        word32PrimTy, word32PrimTyConName,--        int64PrimTyCon,         int64PrimTy, int64PrimTyConName,-        word64PrimTyCon,        word64PrimTy, word64PrimTyConName,--        eqPrimTyCon,            -- ty1 ~# ty2-        eqReprPrimTyCon,        -- ty1 ~R# ty2  (at role Representational)-        eqPhantPrimTyCon,       -- ty1 ~P# ty2  (at role Phantom)-        equalityTyCon,--        -- * SIMD-#include "primop-vector-tys-exports.hs-incl"-  ) where--#include "HsVersions.h"--import GhcPrelude--import {-# SOURCE #-} TysWiredIn-  ( runtimeRepTy, unboxedTupleKind, liftedTypeKind-  , vecRepDataConTyCon, tupleRepDataConTyCon-  , liftedRepDataConTy, unliftedRepDataConTy-  , intRepDataConTy-  , int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy-  , wordRepDataConTy-  , word16RepDataConTy, word8RepDataConTy, word32RepDataConTy, word64RepDataConTy-  , addrRepDataConTy-  , floatRepDataConTy, doubleRepDataConTy-  , vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy-  , vec64DataConTy-  , int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy-  , int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy-  , word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy-  , doubleElemRepDataConTy-  , mkPromotedListTy )--import GHC.Types.Var    ( TyVar, mkTyVar )-import GHC.Types.Name-import GHC.Core.TyCon-import GHC.Types.SrcLoc-import GHC.Types.Unique-import PrelNames-import FastString-import Outputable-import GHC.Core.TyCo.Rep -- Doesn't need special access, but this is easier to avoid-                         -- import loops which show up if you import Type instead--import Data.Char--{--************************************************************************-*                                                                      *-\subsection{Primitive type constructors}-*                                                                      *-************************************************************************--}--primTyCons :: [TyCon]-primTyCons = unexposedPrimTyCons ++ exposedPrimTyCons---- | Primitive 'TyCon's that are defined in "GHC.Prim" but not exposed.--- It's important to keep these separate as we don't want users to be able to--- write them (see #15209) or see them in GHCi's @:browse@ output--- (see #12023).-unexposedPrimTyCons :: [TyCon]-unexposedPrimTyCons-  = [ eqPrimTyCon-    , eqReprPrimTyCon-    , eqPhantPrimTyCon-    ]---- | Primitive 'TyCon's that are defined in, and exported from, "GHC.Prim".-exposedPrimTyCons :: [TyCon]-exposedPrimTyCons-  = [ addrPrimTyCon-    , arrayPrimTyCon-    , byteArrayPrimTyCon-    , arrayArrayPrimTyCon-    , smallArrayPrimTyCon-    , charPrimTyCon-    , doublePrimTyCon-    , floatPrimTyCon-    , intPrimTyCon-    , int8PrimTyCon-    , int16PrimTyCon-    , int32PrimTyCon-    , int64PrimTyCon-    , bcoPrimTyCon-    , weakPrimTyCon-    , mutableArrayPrimTyCon-    , mutableByteArrayPrimTyCon-    , mutableArrayArrayPrimTyCon-    , smallMutableArrayPrimTyCon-    , mVarPrimTyCon-    , tVarPrimTyCon-    , mutVarPrimTyCon-    , realWorldTyCon-    , stablePtrPrimTyCon-    , stableNamePrimTyCon-    , compactPrimTyCon-    , statePrimTyCon-    , voidPrimTyCon-    , proxyPrimTyCon-    , threadIdPrimTyCon-    , wordPrimTyCon-    , word8PrimTyCon-    , word16PrimTyCon-    , word32PrimTyCon-    , word64PrimTyCon--    , tYPETyCon--#include "primop-vector-tycons.hs-incl"-    ]--mkPrimTc :: FastString -> Unique -> TyCon -> Name-mkPrimTc fs unique tycon-  = mkWiredInName gHC_PRIM (mkTcOccFS fs)-                  unique-                  (ATyCon tycon)        -- Relevant TyCon-                  UserSyntax--mkBuiltInPrimTc :: FastString -> Unique -> TyCon -> Name-mkBuiltInPrimTc fs unique tycon-  = mkWiredInName gHC_PRIM (mkTcOccFS fs)-                  unique-                  (ATyCon tycon)        -- Relevant TyCon-                  BuiltInSyntax---charPrimTyConName, intPrimTyConName, int8PrimTyConName, int16PrimTyConName, int32PrimTyConName, int64PrimTyConName, wordPrimTyConName, word32PrimTyConName, word8PrimTyConName, word16PrimTyConName, word64PrimTyConName, addrPrimTyConName, floatPrimTyConName, doublePrimTyConName, statePrimTyConName, proxyPrimTyConName, realWorldTyConName, arrayPrimTyConName, arrayArrayPrimTyConName, smallArrayPrimTyConName, byteArrayPrimTyConName, mutableArrayPrimTyConName, mutableByteArrayPrimTyConName, mutableArrayArrayPrimTyConName, smallMutableArrayPrimTyConName, mutVarPrimTyConName, mVarPrimTyConName, tVarPrimTyConName, stablePtrPrimTyConName, stableNamePrimTyConName, compactPrimTyConName, bcoPrimTyConName, weakPrimTyConName, threadIdPrimTyConName, eqPrimTyConName, eqReprPrimTyConName, eqPhantPrimTyConName, voidPrimTyConName :: Name-charPrimTyConName             = mkPrimTc (fsLit "Char#") charPrimTyConKey charPrimTyCon-intPrimTyConName              = mkPrimTc (fsLit "Int#") intPrimTyConKey  intPrimTyCon-int8PrimTyConName             = mkPrimTc (fsLit "Int8#") int8PrimTyConKey int8PrimTyCon-int16PrimTyConName            = mkPrimTc (fsLit "Int16#") int16PrimTyConKey int16PrimTyCon-int32PrimTyConName            = mkPrimTc (fsLit "Int32#") int32PrimTyConKey int32PrimTyCon-int64PrimTyConName            = mkPrimTc (fsLit "Int64#") int64PrimTyConKey int64PrimTyCon-wordPrimTyConName             = mkPrimTc (fsLit "Word#") wordPrimTyConKey wordPrimTyCon-word8PrimTyConName            = mkPrimTc (fsLit "Word8#") word8PrimTyConKey word8PrimTyCon-word16PrimTyConName           = mkPrimTc (fsLit "Word16#") word16PrimTyConKey word16PrimTyCon-word32PrimTyConName           = mkPrimTc (fsLit "Word32#") word32PrimTyConKey word32PrimTyCon-word64PrimTyConName           = mkPrimTc (fsLit "Word64#") word64PrimTyConKey word64PrimTyCon-addrPrimTyConName             = mkPrimTc (fsLit "Addr#") addrPrimTyConKey addrPrimTyCon-floatPrimTyConName            = mkPrimTc (fsLit "Float#") floatPrimTyConKey floatPrimTyCon-doublePrimTyConName           = mkPrimTc (fsLit "Double#") doublePrimTyConKey doublePrimTyCon-statePrimTyConName            = mkPrimTc (fsLit "State#") statePrimTyConKey statePrimTyCon-voidPrimTyConName             = mkPrimTc (fsLit "Void#") voidPrimTyConKey voidPrimTyCon-proxyPrimTyConName            = mkPrimTc (fsLit "Proxy#") proxyPrimTyConKey proxyPrimTyCon-eqPrimTyConName               = mkPrimTc (fsLit "~#") eqPrimTyConKey eqPrimTyCon-eqReprPrimTyConName           = mkBuiltInPrimTc (fsLit "~R#") eqReprPrimTyConKey eqReprPrimTyCon-eqPhantPrimTyConName          = mkBuiltInPrimTc (fsLit "~P#") eqPhantPrimTyConKey eqPhantPrimTyCon-realWorldTyConName            = mkPrimTc (fsLit "RealWorld") realWorldTyConKey realWorldTyCon-arrayPrimTyConName            = mkPrimTc (fsLit "Array#") arrayPrimTyConKey arrayPrimTyCon-byteArrayPrimTyConName        = mkPrimTc (fsLit "ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon-arrayArrayPrimTyConName           = mkPrimTc (fsLit "ArrayArray#") arrayArrayPrimTyConKey arrayArrayPrimTyCon-smallArrayPrimTyConName       = mkPrimTc (fsLit "SmallArray#") smallArrayPrimTyConKey smallArrayPrimTyCon-mutableArrayPrimTyConName     = mkPrimTc (fsLit "MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon-mutableByteArrayPrimTyConName = mkPrimTc (fsLit "MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon-mutableArrayArrayPrimTyConName= mkPrimTc (fsLit "MutableArrayArray#") mutableArrayArrayPrimTyConKey mutableArrayArrayPrimTyCon-smallMutableArrayPrimTyConName= mkPrimTc (fsLit "SmallMutableArray#") smallMutableArrayPrimTyConKey smallMutableArrayPrimTyCon-mutVarPrimTyConName           = mkPrimTc (fsLit "MutVar#") mutVarPrimTyConKey mutVarPrimTyCon-mVarPrimTyConName             = mkPrimTc (fsLit "MVar#") mVarPrimTyConKey mVarPrimTyCon-tVarPrimTyConName             = mkPrimTc (fsLit "TVar#") tVarPrimTyConKey tVarPrimTyCon-stablePtrPrimTyConName        = mkPrimTc (fsLit "StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon-stableNamePrimTyConName       = mkPrimTc (fsLit "StableName#") stableNamePrimTyConKey stableNamePrimTyCon-compactPrimTyConName          = mkPrimTc (fsLit "Compact#") compactPrimTyConKey compactPrimTyCon-bcoPrimTyConName              = mkPrimTc (fsLit "BCO#") bcoPrimTyConKey bcoPrimTyCon-weakPrimTyConName             = mkPrimTc (fsLit "Weak#") weakPrimTyConKey weakPrimTyCon-threadIdPrimTyConName         = mkPrimTc (fsLit "ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon--{--************************************************************************-*                                                                      *-\subsection{Support code}-*                                                                      *-************************************************************************--alphaTyVars is a list of type variables for use in templates:-        ["a", "b", ..., "z", "t1", "t2", ... ]--}--mkTemplateKindVar :: Kind -> TyVar-mkTemplateKindVar = mkTyVar (mk_tv_name 0 "k")--mkTemplateKindVars :: [Kind] -> [TyVar]--- k0  with unique (mkAlphaTyVarUnique 0)--- k1  with unique (mkAlphaTyVarUnique 1)--- ... etc-mkTemplateKindVars [kind] = [mkTemplateKindVar kind]-  -- Special case for one kind: just "k"-mkTemplateKindVars kinds-  = [ mkTyVar (mk_tv_name u ('k' : show u)) kind-    | (kind, u) <- kinds `zip` [0..] ]-mk_tv_name :: Int -> String -> Name-mk_tv_name u s = mkInternalName (mkAlphaTyVarUnique u)-                                (mkTyVarOccFS (mkFastString s))-                                noSrcSpan--mkTemplateTyVarsFrom :: Int -> [Kind] -> [TyVar]--- a  with unique (mkAlphaTyVarUnique n)--- b  with unique (mkAlphaTyVarUnique n+1)--- ... etc--- Typically called as---   mkTemplateTyVarsFrom (length kv_bndrs) kinds--- where kv_bndrs are the kind-level binders of a TyCon-mkTemplateTyVarsFrom n kinds-  = [ mkTyVar name kind-    | (kind, index) <- zip kinds [0..],-      let ch_ord = index + ord 'a'-          name_str | ch_ord <= ord 'z' = [chr ch_ord]-                   | otherwise         = 't':show index-          name = mk_tv_name (index + n) name_str-    ]--mkTemplateTyVars :: [Kind] -> [TyVar]-mkTemplateTyVars = mkTemplateTyVarsFrom 1--mkTemplateTyConBinders-    :: [Kind]                -- [k1, .., kn]   Kinds of kind-forall'd vars-    -> ([Kind] -> [Kind])    -- Arg is [kv1:k1, ..., kvn:kn]-                             --     same length as first arg-                             -- Result is anon arg kinds-    -> [TyConBinder]-mkTemplateTyConBinders kind_var_kinds mk_anon_arg_kinds-  = kv_bndrs ++ tv_bndrs-  where-    kv_bndrs   = mkTemplateKindTyConBinders kind_var_kinds-    anon_kinds = mk_anon_arg_kinds (mkTyVarTys (binderVars kv_bndrs))-    tv_bndrs   = mkTemplateAnonTyConBindersFrom (length kv_bndrs) anon_kinds--mkTemplateKiTyVars-    :: [Kind]                -- [k1, .., kn]   Kinds of kind-forall'd vars-    -> ([Kind] -> [Kind])    -- Arg is [kv1:k1, ..., kvn:kn]-                             --     same length as first arg-                             -- Result is anon arg kinds [ak1, .., akm]-    -> [TyVar]   -- [kv1:k1, ..., kvn:kn, av1:ak1, ..., avm:akm]--- Example: if you want the tyvars for---   forall (r:RuntimeRep) (a:TYPE r) (b:*). blah--- call mkTemplateKiTyVars [RuntimeRep] (\[r] -> [TYPE r, *])-mkTemplateKiTyVars kind_var_kinds mk_arg_kinds-  = kv_bndrs ++ tv_bndrs-  where-    kv_bndrs   = mkTemplateKindVars kind_var_kinds-    anon_kinds = mk_arg_kinds (mkTyVarTys kv_bndrs)-    tv_bndrs   = mkTemplateTyVarsFrom (length kv_bndrs) anon_kinds--mkTemplateKiTyVar-    :: Kind                  -- [k1, .., kn]   Kind of kind-forall'd var-    -> (Kind -> [Kind])      -- Arg is kv1:k1-                             -- Result is anon arg kinds [ak1, .., akm]-    -> [TyVar]   -- [kv1:k1, ..., kvn:kn, av1:ak1, ..., avm:akm]--- Example: if you want the tyvars for---   forall (r:RuntimeRep) (a:TYPE r) (b:*). blah--- call mkTemplateKiTyVar RuntimeRep (\r -> [TYPE r, *])-mkTemplateKiTyVar kind mk_arg_kinds-  = kv_bndr : tv_bndrs-  where-    kv_bndr    = mkTemplateKindVar kind-    anon_kinds = mk_arg_kinds (mkTyVarTy kv_bndr)-    tv_bndrs   = mkTemplateTyVarsFrom 1 anon_kinds--mkTemplateKindTyConBinders :: [Kind] -> [TyConBinder]--- Makes named, Specified binders-mkTemplateKindTyConBinders kinds = [mkNamedTyConBinder Specified tv | tv <- mkTemplateKindVars kinds]--mkTemplateAnonTyConBinders :: [Kind] -> [TyConBinder]-mkTemplateAnonTyConBinders kinds = mkAnonTyConBinders VisArg (mkTemplateTyVars kinds)--mkTemplateAnonTyConBindersFrom :: Int -> [Kind] -> [TyConBinder]-mkTemplateAnonTyConBindersFrom n kinds = mkAnonTyConBinders VisArg (mkTemplateTyVarsFrom n kinds)--alphaTyVars :: [TyVar]-alphaTyVars = mkTemplateTyVars $ repeat liftedTypeKind--alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar :: TyVar-(alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars--alphaTys :: [Type]-alphaTys = mkTyVarTys alphaTyVars-alphaTy, betaTy, gammaTy, deltaTy :: Type-(alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys--alphaTyVarsUnliftedRep :: [TyVar]-alphaTyVarsUnliftedRep = mkTemplateTyVars $ repeat (tYPE unliftedRepDataConTy)--alphaTyVarUnliftedRep :: TyVar-(alphaTyVarUnliftedRep:_) = alphaTyVarsUnliftedRep--alphaTysUnliftedRep :: [Type]-alphaTysUnliftedRep = mkTyVarTys alphaTyVarsUnliftedRep-alphaTyUnliftedRep :: Type-(alphaTyUnliftedRep:_) = alphaTysUnliftedRep--runtimeRep1TyVar, runtimeRep2TyVar :: TyVar-(runtimeRep1TyVar : runtimeRep2TyVar : _)-  = drop 16 (mkTemplateTyVars (repeat runtimeRepTy))  -- selects 'q','r'--runtimeRep1Ty, runtimeRep2Ty :: Type-runtimeRep1Ty = mkTyVarTy runtimeRep1TyVar-runtimeRep2Ty = mkTyVarTy runtimeRep2TyVar--openAlphaTyVar, openBetaTyVar :: TyVar--- alpha :: TYPE r1--- beta  :: TYPE r2-[openAlphaTyVar,openBetaTyVar]-  = mkTemplateTyVars [tYPE runtimeRep1Ty, tYPE runtimeRep2Ty]--openAlphaTy, openBetaTy :: Type-openAlphaTy = mkTyVarTy openAlphaTyVar-openBetaTy  = mkTyVarTy openBetaTyVar--{--************************************************************************-*                                                                      *-                FunTyCon-*                                                                      *-************************************************************************--}--funTyConName :: Name-funTyConName = mkPrimTyConName (fsLit "->") funTyConKey funTyCon---- | The @(->)@ type constructor.------ @--- (->) :: forall (rep1 :: RuntimeRep) (rep2 :: RuntimeRep).---         TYPE rep1 -> TYPE rep2 -> *--- @-funTyCon :: TyCon-funTyCon = mkFunTyCon funTyConName tc_bndrs tc_rep_nm-  where-    tc_bndrs = [ mkNamedTyConBinder Inferred runtimeRep1TyVar-               , mkNamedTyConBinder Inferred runtimeRep2TyVar ]-               ++ mkTemplateAnonTyConBinders [ tYPE runtimeRep1Ty-                                             , tYPE runtimeRep2Ty-                                             ]-    tc_rep_nm = mkPrelTyConRepName funTyConName--{--************************************************************************-*                                                                      *-                Kinds-*                                                                      *-************************************************************************--Note [TYPE and RuntimeRep]-~~~~~~~~~~~~~~~~~~~~~~~~~~-All types that classify values have a kind of the form (TYPE rr), where--    data RuntimeRep     -- Defined in ghc-prim:GHC.Types-      = LiftedRep-      | UnliftedRep-      | IntRep-      | FloatRep-      .. etc ..--    rr :: RuntimeRep--    TYPE :: RuntimeRep -> TYPE 'LiftedRep  -- Built in--So for example:-    Int        :: TYPE 'LiftedRep-    Array# Int :: TYPE 'UnliftedRep-    Int#       :: TYPE 'IntRep-    Float#     :: TYPE 'FloatRep-    Maybe      :: TYPE 'LiftedRep -> TYPE 'LiftedRep-    (# , #)    :: TYPE r1 -> TYPE r2 -> TYPE (TupleRep [r1, r2])--We abbreviate '*' specially:-    type * = TYPE 'LiftedRep--The 'rr' parameter tells us how the value is represented at runtime.--Generally speaking, you can't be polymorphic in 'rr'.  E.g-   f :: forall (rr:RuntimeRep) (a:TYPE rr). a -> [a]-   f = /\(rr:RuntimeRep) (a:rr) \(a:rr). ...-This is no good: we could not generate code code for 'f', because the-calling convention for 'f' varies depending on whether the argument is-a a Int, Int#, or Float#.  (You could imagine generating specialised-code, one for each instantiation of 'rr', but we don't do that.)--Certain functions CAN be runtime-rep-polymorphic, because the code-generator never has to manipulate a value of type 'a :: TYPE rr'.--* error :: forall (rr:RuntimeRep) (a:TYPE rr). String -> a-  Code generator never has to manipulate the return value.--* unsafeCoerce#, defined in Desugar.mkUnsafeCoercePair:-  Always inlined to be a no-op-     unsafeCoerce# :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)-                             (a :: TYPE r1) (b :: TYPE r2).-                             a -> b--* Unboxed tuples, and unboxed sums, defined in TysWiredIn-  Always inlined, and hence specialised to the call site-     (#,#) :: forall (r1 :: RuntimeRep) (r2 :: RuntimeRep)-                     (a :: TYPE r1) (b :: TYPE r2).-                     a -> b -> TYPE ('TupleRep '[r1, r2])--Note [PrimRep and kindPrimRep]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-As part of its source code, in GHC.Core.TyCon, GHC has-  data PrimRep = LiftedRep | UnliftedRep | IntRep | FloatRep | ...etc...--Notice that- * RuntimeRep is part of the syntax tree of the program being compiled-     (defined in a library: ghc-prim:GHC.Types)- * PrimRep is part of GHC's source code.-     (defined in GHC.Core.TyCon)--We need to get from one to the other; that is what kindPrimRep does.-Suppose we have a value-   (v :: t) where (t :: k)-Given this kind-    k = TyConApp "TYPE" [rep]-GHC needs to be able to figure out how 'v' is represented at runtime.-It expects 'rep' to be form-    TyConApp rr_dc args-where 'rr_dc' is a promoteed data constructor from RuntimeRep. So-now we need to go from 'dc' to the corresponding PrimRep.  We store this-PrimRep in the promoted data constructor itself: see TyCon.promDcRepInfo.---}--tYPETyCon :: TyCon-tYPETyConName :: Name--tYPETyCon = mkKindTyCon tYPETyConName-                        (mkTemplateAnonTyConBinders [runtimeRepTy])-                        liftedTypeKind-                        [Nominal]-                        (mkPrelTyConRepName tYPETyConName)------------------------------- ... and now their names---- If you edit these, you may need to update the GHC formalism--- See Note [GHC Formalism] in GHC.Core.Lint-tYPETyConName             = mkPrimTyConName (fsLit "TYPE") tYPETyConKey tYPETyCon--mkPrimTyConName :: FastString -> Unique -> TyCon -> Name-mkPrimTyConName = mkPrimTcName BuiltInSyntax-  -- All of the super kinds and kinds are defined in Prim,-  -- and use BuiltInSyntax, because they are never in scope in the source--mkPrimTcName :: BuiltInSyntax -> FastString -> Unique -> TyCon -> Name-mkPrimTcName built_in_syntax occ key tycon-  = mkWiredInName gHC_PRIM (mkTcOccFS occ) key (ATyCon tycon) built_in_syntax---------------------------------- | Given a RuntimeRep, applies TYPE to it.--- see Note [TYPE and RuntimeRep]-tYPE :: Type -> Type-tYPE rr = TyConApp tYPETyCon [rr]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}-*                                                                      *-************************************************************************--}---- only used herein-pcPrimTyCon :: Name -> [Role] -> PrimRep -> TyCon-pcPrimTyCon name roles rep-  = mkPrimTyCon name binders result_kind roles-  where-    binders     = mkTemplateAnonTyConBinders (map (const liftedTypeKind) roles)-    result_kind = tYPE (primRepToRuntimeRep rep)---- | Convert a 'PrimRep' to a 'Type' of kind RuntimeRep--- Defined here to avoid (more) module loops-primRepToRuntimeRep :: PrimRep -> Type-primRepToRuntimeRep rep = case rep of-  VoidRep       -> TyConApp tupleRepDataConTyCon [mkPromotedListTy runtimeRepTy []]-  LiftedRep     -> liftedRepDataConTy-  UnliftedRep   -> unliftedRepDataConTy-  IntRep        -> intRepDataConTy-  Int8Rep       -> int8RepDataConTy-  Int16Rep      -> int16RepDataConTy-  Int32Rep      -> int32RepDataConTy-  Int64Rep      -> int64RepDataConTy-  WordRep       -> wordRepDataConTy-  Word8Rep      -> word8RepDataConTy-  Word16Rep     -> word16RepDataConTy-  Word32Rep     -> word32RepDataConTy-  Word64Rep     -> word64RepDataConTy-  AddrRep       -> addrRepDataConTy-  FloatRep      -> floatRepDataConTy-  DoubleRep     -> doubleRepDataConTy-  VecRep n elem -> TyConApp vecRepDataConTyCon [n', elem']-    where-      n' = case n of-        2  -> vec2DataConTy-        4  -> vec4DataConTy-        8  -> vec8DataConTy-        16 -> vec16DataConTy-        32 -> vec32DataConTy-        64 -> vec64DataConTy-        _  -> pprPanic "Disallowed VecCount" (ppr n)--      elem' = case elem of-        Int8ElemRep   -> int8ElemRepDataConTy-        Int16ElemRep  -> int16ElemRepDataConTy-        Int32ElemRep  -> int32ElemRepDataConTy-        Int64ElemRep  -> int64ElemRepDataConTy-        Word8ElemRep  -> word8ElemRepDataConTy-        Word16ElemRep -> word16ElemRepDataConTy-        Word32ElemRep -> word32ElemRepDataConTy-        Word64ElemRep -> word64ElemRepDataConTy-        FloatElemRep  -> floatElemRepDataConTy-        DoubleElemRep -> doubleElemRepDataConTy--pcPrimTyCon0 :: Name -> PrimRep -> TyCon-pcPrimTyCon0 name rep-  = pcPrimTyCon name [] rep--charPrimTy :: Type-charPrimTy      = mkTyConTy charPrimTyCon-charPrimTyCon :: TyCon-charPrimTyCon   = pcPrimTyCon0 charPrimTyConName WordRep--intPrimTy :: Type-intPrimTy       = mkTyConTy intPrimTyCon-intPrimTyCon :: TyCon-intPrimTyCon    = pcPrimTyCon0 intPrimTyConName IntRep--int8PrimTy :: Type-int8PrimTy     = mkTyConTy int8PrimTyCon-int8PrimTyCon :: TyCon-int8PrimTyCon  = pcPrimTyCon0 int8PrimTyConName Int8Rep--int16PrimTy :: Type-int16PrimTy    = mkTyConTy int16PrimTyCon-int16PrimTyCon :: TyCon-int16PrimTyCon = pcPrimTyCon0 int16PrimTyConName Int16Rep--int32PrimTy :: Type-int32PrimTy     = mkTyConTy int32PrimTyCon-int32PrimTyCon :: TyCon-int32PrimTyCon  = pcPrimTyCon0 int32PrimTyConName Int32Rep--int64PrimTy :: Type-int64PrimTy     = mkTyConTy int64PrimTyCon-int64PrimTyCon :: TyCon-int64PrimTyCon  = pcPrimTyCon0 int64PrimTyConName Int64Rep--wordPrimTy :: Type-wordPrimTy      = mkTyConTy wordPrimTyCon-wordPrimTyCon :: TyCon-wordPrimTyCon   = pcPrimTyCon0 wordPrimTyConName WordRep--word8PrimTy :: Type-word8PrimTy     = mkTyConTy word8PrimTyCon-word8PrimTyCon :: TyCon-word8PrimTyCon  = pcPrimTyCon0 word8PrimTyConName Word8Rep--word16PrimTy :: Type-word16PrimTy    = mkTyConTy word16PrimTyCon-word16PrimTyCon :: TyCon-word16PrimTyCon = pcPrimTyCon0 word16PrimTyConName Word16Rep--word32PrimTy :: Type-word32PrimTy    = mkTyConTy word32PrimTyCon-word32PrimTyCon :: TyCon-word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName Word32Rep--word64PrimTy :: Type-word64PrimTy    = mkTyConTy word64PrimTyCon-word64PrimTyCon :: TyCon-word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep--addrPrimTy :: Type-addrPrimTy      = mkTyConTy addrPrimTyCon-addrPrimTyCon :: TyCon-addrPrimTyCon   = pcPrimTyCon0 addrPrimTyConName AddrRep--floatPrimTy     :: Type-floatPrimTy     = mkTyConTy floatPrimTyCon-floatPrimTyCon :: TyCon-floatPrimTyCon  = pcPrimTyCon0 floatPrimTyConName FloatRep--doublePrimTy :: Type-doublePrimTy    = mkTyConTy doublePrimTyCon-doublePrimTyCon :: TyCon-doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep--{--************************************************************************-*                                                                      *-\subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}-*                                                                      *-************************************************************************--Note [The equality types story]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-GHC sports a veritable menagerie of equality types:--         Type or  Lifted?  Hetero?  Role      Built in         Defining module-         class?    L/U                        TyCon-------------------------------------------------------------------------------------------~#         T        U      hetero   nominal   eqPrimTyCon      GHC.Prim-~~         C        L      hetero   nominal   heqTyCon         GHC.Types-~          C        L      homo     nominal   eqTyCon          GHC.Types-:~:        T        L      homo     nominal   (not built-in)   Data.Type.Equality-:~~:       T        L      hetero   nominal   (not built-in)   Data.Type.Equality--~R#        T        U      hetero   repr      eqReprPrimTy     GHC.Prim-Coercible  C        L      homo     repr      coercibleTyCon   GHC.Types-Coercion   T        L      homo     repr      (not built-in)   Data.Type.Coercion-~P#        T        U      hetero   phantom   eqPhantPrimTyCon GHC.Prim--Recall that "hetero" means the equality can related types of different-kinds. Knowing that (t1 ~# t2) or (t1 ~R# t2) or even that (t1 ~P# t2)-also means that (k1 ~# k2), where (t1 :: k1) and (t2 :: k2).--To produce less confusion for end users, when not dumping and without--fprint-equality-relations, each of these groups is printed as the bottommost-listed equality. That is, (~#) and (~~) are both rendered as (~) in-error messages, and (~R#) is rendered as Coercible.--Let's take these one at a time:--    ---------------------------    (~#) :: forall k1 k2. k1 -> k2 -> #-    ---------------------------This is The Type Of Equality in GHC. It classifies nominal coercions.-This type is used in the solver for recording equality constraints.-It responds "yes" to Type.isEqPrimPred and classifies as an EqPred in-Type.classifyPredType.--All wanted constraints of this type are built with coercion holes.-(See Note [Coercion holes] in GHC.Core.TyCo.Rep.) But see also-Note [Deferred errors for coercion holes] in TcErrors to see how-equality constraints are deferred.--Within GHC, ~# is called eqPrimTyCon, and it is defined in TysPrim.---    ---------------------------    (~~) :: forall k1 k2. k1 -> k2 -> Constraint-    ---------------------------This is (almost) an ordinary class, defined as if by-  class a ~# b => a ~~ b-  instance a ~# b => a ~~ b-Here's what's unusual about it:-- * We can't actually declare it that way because we don't have syntax for ~#.-   And ~# isn't a constraint, so even if we could write it, it wouldn't kind-   check.-- * Users cannot write instances of it.-- * It is "naturally coherent". This means that the solver won't hesitate to-   solve a goal of type (a ~~ b) even if there is, say (Int ~~ c) in the-   context. (Normally, it waits to learn more, just in case the given-   influences what happens next.) See Note [Naturally coherent classes]-   in TcInteract.-- * It always terminates. That is, in the UndecidableInstances checks, we-   don't worry if a (~~) constraint is too big, as we know that solving-   equality terminates.--On the other hand, this behaves just like any class w.r.t. eager superclass-unpacking in the solver. So a lifted equality given quickly becomes an unlifted-equality given. This is good, because the solver knows all about unlifted-equalities. There is some special-casing in TcInteract.matchClassInst to-pretend that there is an instance of this class, as we can't write the instance-in Haskell.--Within GHC, ~~ is called heqTyCon, and it is defined in TysWiredIn.---    ---------------------------    (~) :: forall k. k -> k -> Constraint-    ---------------------------This is /exactly/ like (~~), except with a homogeneous kind.-It is an almost-ordinary class defined as if by-  class a ~# b => (a :: k) ~ (b :: k)-  instance a ~# b => a ~ b-- * All the bullets for (~~) apply-- * In addition (~) is magical syntax, as ~ is a reserved symbol.-   It cannot be exported or imported.--Within GHC, ~ is called eqTyCon, and it is defined in TysWiredIn.--Historical note: prior to July 18 (~) was defined as a-  more-ordinary class with (~~) as a superclass.  But that made it-  special in different ways; and the extra superclass selections to-  get from (~) to (~#) via (~~) were tiresome.  Now it's defined-  uniformly with (~~) and Coercible; much nicer.)---    ---------------------------    (:~:) :: forall k. k -> k -> *-    (:~~:) :: forall k1 k2. k1 -> k2 -> *-    ---------------------------These are perfectly ordinary GADTs, wrapping (~) and (~~) resp.-They are not defined within GHC at all.---    ---------------------------    (~R#) :: forall k1 k2. k1 -> k2 -> #-    ---------------------------The is the representational analogue of ~#. This is the type of representational-equalities that the solver works on. All wanted constraints of this type are-built with coercion holes.--Within GHC, ~R# is called eqReprPrimTyCon, and it is defined in TysPrim.---    ---------------------------    Coercible :: forall k. k -> k -> Constraint-    ---------------------------This is quite like (~~) in the way it's defined and treated within GHC, but-it's homogeneous. Homogeneity helps with type inference (as GHC can solve one-kind from the other) and, in my (Richard's) estimation, will be more intuitive-for users.--An alternative design included HCoercible (like (~~)) and Coercible (like (~)).-One annoyance was that we want `coerce :: Coercible a b => a -> b`, and-we need the type of coerce to be fully wired-in. So the HCoercible/Coercible-split required that both types be fully wired-in. Instead of doing this,-I just got rid of HCoercible, as I'm not sure who would use it, anyway.--Within GHC, Coercible is called coercibleTyCon, and it is defined in-TysWiredIn.---    ---------------------------    Coercion :: forall k. k -> k -> *-    ---------------------------This is a perfectly ordinary GADT, wrapping Coercible. It is not defined-within GHC at all.---    ---------------------------    (~P#) :: forall k1 k2. k1 -> k2 -> #-    ---------------------------This is the phantom analogue of ~# and it is barely used at all.-(The solver has no idea about this one.) Here is the motivation:--    data Phant a = MkPhant-    type role Phant phantom--    Phant <Int, Bool>_P :: Phant Int ~P# Phant Bool--We just need to have something to put on that last line. You probably-don't need to worry about it.----Note [The State# TyCon]-~~~~~~~~~~~~~~~~~~~~~~~-State# is the primitive, unlifted type of states.  It has one type parameter,-thus-        State# RealWorld-or-        State# s--where s is a type variable. The only purpose of the type parameter is to-keep different state threads separate.  It is represented by nothing at all.--The type parameter to State# is intended to keep separate threads separate.-Even though this parameter is not used in the definition of State#, it is-given role Nominal to enforce its intended use.--}--mkStatePrimTy :: Type -> Type-mkStatePrimTy ty = TyConApp statePrimTyCon [ty]--statePrimTyCon :: TyCon   -- See Note [The State# TyCon]-statePrimTyCon   = pcPrimTyCon statePrimTyConName [Nominal] VoidRep--{--RealWorld is deeply magical.  It is *primitive*, but it is not-*unlifted* (hence ptrArg).  We never manipulate values of type-RealWorld; it's only used in the type system, to parameterise State#.--}--realWorldTyCon :: TyCon-realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName [] liftedTypeKind []-realWorldTy :: Type-realWorldTy          = mkTyConTy realWorldTyCon-realWorldStatePrimTy :: Type-realWorldStatePrimTy = mkStatePrimTy realWorldTy        -- State# RealWorld---- Note: the ``state-pairing'' types are not truly primitive,--- so they are defined in \tr{TysWiredIn.hs}, not here.---voidPrimTy :: Type-voidPrimTy = TyConApp voidPrimTyCon []--voidPrimTyCon :: TyCon-voidPrimTyCon    = pcPrimTyCon voidPrimTyConName [] VoidRep--mkProxyPrimTy :: Type -> Type -> Type-mkProxyPrimTy k ty = TyConApp proxyPrimTyCon [k, ty]--proxyPrimTyCon :: TyCon-proxyPrimTyCon = mkPrimTyCon proxyPrimTyConName binders res_kind [Nominal,Phantom]-  where-     -- Kind: forall k. k -> TYPE (Tuple '[])-     binders = mkTemplateTyConBinders [liftedTypeKind] id-     res_kind = unboxedTupleKind []---{- *********************************************************************-*                                                                      *-                Primitive equality constraints-    See Note [The equality types story]-*                                                                      *-********************************************************************* -}--eqPrimTyCon :: TyCon  -- The representation type for equality predicates-                      -- See Note [The equality types story]-eqPrimTyCon  = mkPrimTyCon eqPrimTyConName binders res_kind roles-  where-    -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])-    binders  = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id-    res_kind = unboxedTupleKind []-    roles    = [Nominal, Nominal, Nominal, Nominal]---- like eqPrimTyCon, but the type for *Representational* coercions--- this should only ever appear as the type of a covar. Its role is--- interpreted in coercionRole-eqReprPrimTyCon :: TyCon   -- See Note [The equality types story]-eqReprPrimTyCon = mkPrimTyCon eqReprPrimTyConName binders res_kind roles-  where-    -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])-    binders  = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id-    res_kind = unboxedTupleKind []-    roles    = [Nominal, Nominal, Representational, Representational]---- like eqPrimTyCon, but the type for *Phantom* coercions.--- This is only used to make higher-order equalities. Nothing--- should ever actually have this type!-eqPhantPrimTyCon :: TyCon-eqPhantPrimTyCon = mkPrimTyCon eqPhantPrimTyConName binders res_kind roles-  where-    -- Kind :: forall k1 k2. k1 -> k2 -> TYPE (Tuple '[])-    binders  = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id-    res_kind = unboxedTupleKind []-    roles    = [Nominal, Nominal, Phantom, Phantom]---- | Given a Role, what TyCon is the type of equality predicates at that role?-equalityTyCon :: Role -> TyCon-equalityTyCon Nominal          = eqPrimTyCon-equalityTyCon Representational = eqReprPrimTyCon-equalityTyCon Phantom          = eqPhantPrimTyCon--{- *********************************************************************-*                                                                      *-             The primitive array types-*                                                                      *-********************************************************************* -}--arrayPrimTyCon, mutableArrayPrimTyCon, mutableByteArrayPrimTyCon,-    byteArrayPrimTyCon, arrayArrayPrimTyCon, mutableArrayArrayPrimTyCon,-    smallArrayPrimTyCon, smallMutableArrayPrimTyCon :: TyCon-arrayPrimTyCon             = pcPrimTyCon arrayPrimTyConName             [Representational] UnliftedRep-mutableArrayPrimTyCon      = pcPrimTyCon  mutableArrayPrimTyConName     [Nominal, Representational] UnliftedRep-mutableByteArrayPrimTyCon  = pcPrimTyCon mutableByteArrayPrimTyConName  [Nominal] UnliftedRep-byteArrayPrimTyCon         = pcPrimTyCon0 byteArrayPrimTyConName        UnliftedRep-arrayArrayPrimTyCon        = pcPrimTyCon0 arrayArrayPrimTyConName       UnliftedRep-mutableArrayArrayPrimTyCon = pcPrimTyCon mutableArrayArrayPrimTyConName [Nominal] UnliftedRep-smallArrayPrimTyCon        = pcPrimTyCon smallArrayPrimTyConName        [Representational] UnliftedRep-smallMutableArrayPrimTyCon = pcPrimTyCon smallMutableArrayPrimTyConName [Nominal, Representational] UnliftedRep--mkArrayPrimTy :: Type -> Type-mkArrayPrimTy elt           = TyConApp arrayPrimTyCon [elt]-byteArrayPrimTy :: Type-byteArrayPrimTy             = mkTyConTy byteArrayPrimTyCon-mkArrayArrayPrimTy :: Type-mkArrayArrayPrimTy = mkTyConTy arrayArrayPrimTyCon-mkSmallArrayPrimTy :: Type -> Type-mkSmallArrayPrimTy elt = TyConApp smallArrayPrimTyCon [elt]-mkMutableArrayPrimTy :: Type -> Type -> Type-mkMutableArrayPrimTy s elt  = TyConApp mutableArrayPrimTyCon [s, elt]-mkMutableByteArrayPrimTy :: Type -> Type-mkMutableByteArrayPrimTy s  = TyConApp mutableByteArrayPrimTyCon [s]-mkMutableArrayArrayPrimTy :: Type -> Type-mkMutableArrayArrayPrimTy s = TyConApp mutableArrayArrayPrimTyCon [s]-mkSmallMutableArrayPrimTy :: Type -> Type -> Type-mkSmallMutableArrayPrimTy s elt = TyConApp smallMutableArrayPrimTyCon [s, elt]---{- *********************************************************************-*                                                                      *-                The mutable variable type-*                                                                      *-********************************************************************* -}--mutVarPrimTyCon :: TyCon-mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName [Nominal, Representational] UnliftedRep--mkMutVarPrimTy :: Type -> Type -> Type-mkMutVarPrimTy s elt        = TyConApp mutVarPrimTyCon [s, elt]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-synch-var]{The synchronizing variable type}-*                                                                      *-************************************************************************--}--mVarPrimTyCon :: TyCon-mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName [Nominal, Representational] UnliftedRep--mkMVarPrimTy :: Type -> Type -> Type-mkMVarPrimTy s elt          = TyConApp mVarPrimTyCon [s, elt]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-stm-var]{The transactional variable type}-*                                                                      *-************************************************************************--}--tVarPrimTyCon :: TyCon-tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName [Nominal, Representational] UnliftedRep--mkTVarPrimTy :: Type -> Type -> Type-mkTVarPrimTy s elt = TyConApp tVarPrimTyCon [s, elt]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-stable-ptrs]{The stable-pointer type}-*                                                                      *-************************************************************************--}--stablePtrPrimTyCon :: TyCon-stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName [Representational] AddrRep--mkStablePtrPrimTy :: Type -> Type-mkStablePtrPrimTy ty = TyConApp stablePtrPrimTyCon [ty]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-stable-names]{The stable-name type}-*                                                                      *-************************************************************************--}--stableNamePrimTyCon :: TyCon-stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName [Phantom] UnliftedRep--mkStableNamePrimTy :: Type -> Type-mkStableNamePrimTy ty = TyConApp stableNamePrimTyCon [ty]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-compact-nfdata]{The Compact NFData (CNF) type}-*                                                                      *-************************************************************************--}--compactPrimTyCon :: TyCon-compactPrimTyCon = pcPrimTyCon0 compactPrimTyConName UnliftedRep--compactPrimTy :: Type-compactPrimTy = mkTyConTy compactPrimTyCon--{--************************************************************************-*                                                                      *-\subsection[TysPrim-BCOs]{The ``bytecode object'' type}-*                                                                      *-************************************************************************--}---- Unlike most other primitive types, BCO is lifted. This is because in--- general a BCO may be a thunk for the reasons given in Note [Updatable CAF--- BCOs] in GHCi.CreateBCO.-bcoPrimTy    :: Type-bcoPrimTy    = mkTyConTy bcoPrimTyCon-bcoPrimTyCon :: TyCon-bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName UnliftedRep--{--************************************************************************-*                                                                      *-\subsection[TysPrim-Weak]{The ``weak pointer'' type}-*                                                                      *-************************************************************************--}--weakPrimTyCon :: TyCon-weakPrimTyCon = pcPrimTyCon weakPrimTyConName [Representational] UnliftedRep--mkWeakPrimTy :: Type -> Type-mkWeakPrimTy v = TyConApp weakPrimTyCon [v]--{--************************************************************************-*                                                                      *-\subsection[TysPrim-thread-ids]{The ``thread id'' type}-*                                                                      *-************************************************************************--A thread id is represented by a pointer to the TSO itself, to ensure-that they are always unique and we can always find the TSO for a given-thread id.  However, this has the unfortunate consequence that a-ThreadId# for a given thread is treated as a root by the garbage-collector and can keep TSOs around for too long.--Hence the programmer API for thread manipulation uses a weak pointer-to the thread id internally.--}--threadIdPrimTy :: Type-threadIdPrimTy    = mkTyConTy threadIdPrimTyCon-threadIdPrimTyCon :: TyCon-threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName UnliftedRep--{--************************************************************************-*                                                                      *-\subsection{SIMD vector types}-*                                                                      *-************************************************************************--}--#include "primop-vector-tys.hs-incl"
− compiler/prelude/TysWiredIn.hs 
@@ -1,1689 +0,0 @@-{--(c) The GRASP Project, Glasgow University, 1994-1998--\section[TysWiredIn]{Wired-in knowledge about {\em non-primitive} types}--}--{-# LANGUAGE CPP #-}-{-# LANGUAGE OverloadedStrings #-}--{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}---- | This module is about types that can be defined in Haskell, but which---   must be wired into the compiler nonetheless.  C.f module TysPrim-module TysWiredIn (-        -- * Helper functions defined here-        mkWiredInTyConName, -- This is used in TcTypeNats to define the-                            -- built-in functions for evaluation.--        mkWiredInIdName,    -- used in GHC.Types.Id.Make--        -- * All wired in things-        wiredInTyCons, isBuiltInOcc_maybe,--        -- * Bool-        boolTy, boolTyCon, boolTyCon_RDR, boolTyConName,-        trueDataCon,  trueDataConId,  true_RDR,-        falseDataCon, falseDataConId, false_RDR,-        promotedFalseDataCon, promotedTrueDataCon,--        -- * Ordering-        orderingTyCon,-        ordLTDataCon, ordLTDataConId,-        ordEQDataCon, ordEQDataConId,-        ordGTDataCon, ordGTDataConId,-        promotedLTDataCon, promotedEQDataCon, promotedGTDataCon,--        -- * Boxing primitive types-        boxingDataCon_maybe,--        -- * Char-        charTyCon, charDataCon, charTyCon_RDR,-        charTy, stringTy, charTyConName,--        -- * Double-        doubleTyCon, doubleDataCon, doubleTy, doubleTyConName,--        -- * Float-        floatTyCon, floatDataCon, floatTy, floatTyConName,--        -- * Int-        intTyCon, intDataCon, intTyCon_RDR, intDataCon_RDR, intTyConName,-        intTy,--        -- * Word-        wordTyCon, wordDataCon, wordTyConName, wordTy,--        -- * Word8-        word8TyCon, word8DataCon, word8TyConName, word8Ty,--        -- * List-        listTyCon, listTyCon_RDR, listTyConName, listTyConKey,-        nilDataCon, nilDataConName, nilDataConKey,-        consDataCon_RDR, consDataCon, consDataConName,-        promotedNilDataCon, promotedConsDataCon,-        mkListTy, mkPromotedListTy,--        -- * Maybe-        maybeTyCon, maybeTyConName,-        nothingDataCon, nothingDataConName, promotedNothingDataCon,-        justDataCon, justDataConName, promotedJustDataCon,--        -- * Tuples-        mkTupleTy, mkTupleTy1, mkBoxedTupleTy, mkTupleStr,-        tupleTyCon, tupleDataCon, tupleTyConName,-        promotedTupleDataCon,-        unitTyCon, unitDataCon, unitDataConId, unitTy, unitTyConKey,-        pairTyCon,-        unboxedUnitTyCon, unboxedUnitDataCon,-        unboxedTupleKind, unboxedSumKind,--        -- ** Constraint tuples-        cTupleTyConName, cTupleTyConNames, isCTupleTyConName,-        cTupleTyConNameArity_maybe,-        cTupleDataConName, cTupleDataConNames,--        -- * Any-        anyTyCon, anyTy, anyTypeOfKind,--        -- * Recovery TyCon-        makeRecoveryTyCon,--        -- * Sums-        mkSumTy, sumTyCon, sumDataCon,--        -- * Kinds-        typeNatKindCon, typeNatKind, typeSymbolKindCon, typeSymbolKind,-        isLiftedTypeKindTyConName, liftedTypeKind,-        typeToTypeKind, constraintKind,-        liftedTypeKindTyCon, constraintKindTyCon,  constraintKindTyConName,-        liftedTypeKindTyConName,--        -- * Equality predicates-        heqTyCon, heqTyConName, heqClass, heqDataCon,-        eqTyCon, eqTyConName, eqClass, eqDataCon, eqTyCon_RDR,-        coercibleTyCon, coercibleTyConName, coercibleDataCon, coercibleClass,--        -- * RuntimeRep and friends-        runtimeRepTyCon, vecCountTyCon, vecElemTyCon,--        runtimeRepTy, liftedRepTy, liftedRepDataCon, liftedRepDataConTyCon,--        vecRepDataConTyCon, tupleRepDataConTyCon, sumRepDataConTyCon,--        liftedRepDataConTy, unliftedRepDataConTy,-        intRepDataConTy,-        int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,-        wordRepDataConTy,-        word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,-        addrRepDataConTy,-        floatRepDataConTy, doubleRepDataConTy,--        vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,-        vec64DataConTy,--        int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,-        int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,-        word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,-        doubleElemRepDataConTy-    ) where--#include "HsVersions.h"--import GhcPrelude--import {-# SOURCE #-} GHC.Types.Id.Make ( mkDataConWorkId, mkDictSelId )---- friends:-import PrelNames-import TysPrim-import {-# SOURCE #-} KnownUniques---- others:-import GHC.Core.Coercion.Axiom-import GHC.Types.Id-import Constants        ( mAX_TUPLE_SIZE, mAX_CTUPLE_SIZE, mAX_SUM_SIZE )-import GHC.Types.Module ( Module )-import GHC.Core.Type-import GHC.Types.RepType-import GHC.Core.DataCon-import {-# SOURCE #-} GHC.Core.ConLike-import GHC.Core.TyCon-import GHC.Core.Class     ( Class, mkClass )-import GHC.Types.Name.Reader-import GHC.Types.Name as Name-import GHC.Types.Name.Env ( NameEnv, mkNameEnv, lookupNameEnv, lookupNameEnv_NF )-import GHC.Types.Name.Set ( NameSet, mkNameSet, elemNameSet )-import GHC.Types.Basic-import GHC.Types.ForeignCall-import GHC.Types.SrcLoc   ( noSrcSpan )-import GHC.Types.Unique-import Data.Array-import FastString-import Outputable-import Util-import BooleanFormula   ( mkAnd )--import qualified Data.ByteString.Char8 as BS--import Data.List        ( elemIndex )--alpha_tyvar :: [TyVar]-alpha_tyvar = [alphaTyVar]--alpha_ty :: [Type]-alpha_ty = [alphaTy]--{--Note [Wiring in RuntimeRep]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-The RuntimeRep type (and friends) in GHC.Types has a bunch of constructors,-making it a pain to wire in. To ease the pain somewhat, we use lists of-the different bits, like Uniques, Names, DataCons. These lists must be-kept in sync with each other. The rule is this: use the order as declared-in GHC.Types. All places where such lists exist should contain a reference-to this Note, so a search for this Note's name should find all the lists.--See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType.--************************************************************************-*                                                                      *-\subsection{Wired in type constructors}-*                                                                      *-************************************************************************--If you change which things are wired in, make sure you change their-names in PrelNames, so they use wTcQual, wDataQual, etc--}---- This list is used only to define PrelInfo.wiredInThings. That in turn--- is used to initialise the name environment carried around by the renamer.--- This means that if we look up the name of a TyCon (or its implicit binders)--- that occurs in this list that name will be assigned the wired-in key we--- define here.------ Because of their infinite nature, this list excludes tuples, Any and implicit--- parameter TyCons (see Note [Built-in syntax and the OrigNameCache]).------ See also Note [Known-key names]-wiredInTyCons :: [TyCon]--wiredInTyCons = [ -- Units are not treated like other tuples, because they-                  -- are defined in GHC.Base, and there's only a few of them. We-                  -- put them in wiredInTyCons so that they will pre-populate-                  -- the name cache, so the parser in isBuiltInOcc_maybe doesn't-                  -- need to look out for them.-                  unitTyCon-                , unboxedUnitTyCon-                , anyTyCon-                , boolTyCon-                , charTyCon-                , doubleTyCon-                , floatTyCon-                , intTyCon-                , wordTyCon-                , word8TyCon-                , listTyCon-                , maybeTyCon-                , heqTyCon-                , eqTyCon-                , coercibleTyCon-                , typeNatKindCon-                , typeSymbolKindCon-                , runtimeRepTyCon-                , vecCountTyCon-                , vecElemTyCon-                , constraintKindTyCon-                , liftedTypeKindTyCon-                ]--mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name-mkWiredInTyConName built_in modu fs unique tycon-  = mkWiredInName modu (mkTcOccFS fs) unique-                  (ATyCon tycon)        -- Relevant TyCon-                  built_in--mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name-mkWiredInDataConName built_in modu fs unique datacon-  = mkWiredInName modu (mkDataOccFS fs) unique-                  (AConLike (RealDataCon datacon))    -- Relevant DataCon-                  built_in--mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name-mkWiredInIdName mod fs uniq id- = mkWiredInName mod (mkOccNameFS Name.varName fs) uniq (AnId id) UserSyntax---- See Note [Kind-changing of (~) and Coercible]--- in libraries/ghc-prim/GHC/Types.hs-eqTyConName, eqDataConName, eqSCSelIdName :: Name-eqTyConName   = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "~")   eqTyConKey   eqTyCon-eqDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "Eq#") eqDataConKey eqDataCon-eqSCSelIdName = mkWiredInIdName gHC_TYPES (fsLit "eq_sel") eqSCSelIdKey eqSCSelId--{- Note [eqTyCon (~) is built-in syntax]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The (~) type operator used in equality constraints (a~b) is considered built-in-syntax. This has a few consequences:--* The user is not allowed to define their own type constructors with this name:--    ghci> class a ~ b-    <interactive>:1:1: error: Illegal binding of built-in syntax: ~--* Writing (a ~ b) does not require enabling -XTypeOperators. It does, however,-  require -XGADTs or -XTypeFamilies.--* The (~) type operator is always in scope. It doesn't need to be be imported,-  and it cannot be hidden.--* We have a bunch of special cases in the compiler to arrange all of the above.--There's no particular reason for (~) to be special, but fixing this would be a-breaking change.--}-eqTyCon_RDR :: RdrName-eqTyCon_RDR = nameRdrName eqTyConName---- See Note [Kind-changing of (~) and Coercible]--- in libraries/ghc-prim/GHC/Types.hs-heqTyConName, heqDataConName, heqSCSelIdName :: Name-heqTyConName   = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "~~")   heqTyConKey      heqTyCon-heqDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "HEq#") heqDataConKey heqDataCon-heqSCSelIdName = mkWiredInIdName gHC_TYPES (fsLit "heq_sel") heqSCSelIdKey heqSCSelId---- See Note [Kind-changing of (~) and Coercible] in libraries/ghc-prim/GHC/Types.hs-coercibleTyConName, coercibleDataConName, coercibleSCSelIdName :: Name-coercibleTyConName   = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Coercible")  coercibleTyConKey   coercibleTyCon-coercibleDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "MkCoercible") coercibleDataConKey coercibleDataCon-coercibleSCSelIdName = mkWiredInIdName gHC_TYPES (fsLit "coercible_sel") coercibleSCSelIdKey coercibleSCSelId--charTyConName, charDataConName, intTyConName, intDataConName :: Name-charTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Char") charTyConKey charTyCon-charDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "C#") charDataConKey charDataCon-intTyConName      = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Int") intTyConKey   intTyCon-intDataConName    = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "I#") intDataConKey  intDataCon--boolTyConName, falseDataConName, trueDataConName :: Name-boolTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Bool") boolTyConKey boolTyCon-falseDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "False") falseDataConKey falseDataCon-trueDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "True")  trueDataConKey  trueDataCon--listTyConName, nilDataConName, consDataConName :: Name-listTyConName     = mkWiredInTyConName   BuiltInSyntax gHC_TYPES (fsLit "[]") listTyConKey listTyCon-nilDataConName    = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit "[]") nilDataConKey nilDataCon-consDataConName   = mkWiredInDataConName BuiltInSyntax gHC_TYPES (fsLit ":") consDataConKey consDataCon--maybeTyConName, nothingDataConName, justDataConName :: Name-maybeTyConName     = mkWiredInTyConName   UserSyntax gHC_MAYBE (fsLit "Maybe")-                                          maybeTyConKey maybeTyCon-nothingDataConName = mkWiredInDataConName UserSyntax gHC_MAYBE (fsLit "Nothing")-                                          nothingDataConKey nothingDataCon-justDataConName    = mkWiredInDataConName UserSyntax gHC_MAYBE (fsLit "Just")-                                          justDataConKey justDataCon--wordTyConName, wordDataConName, word8TyConName, word8DataConName :: Name-wordTyConName      = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Word")   wordTyConKey     wordTyCon-wordDataConName    = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "W#")     wordDataConKey   wordDataCon-word8TyConName     = mkWiredInTyConName   UserSyntax gHC_WORD  (fsLit "Word8")  word8TyConKey    word8TyCon-word8DataConName   = mkWiredInDataConName UserSyntax gHC_WORD  (fsLit "W8#")    word8DataConKey  word8DataCon--floatTyConName, floatDataConName, doubleTyConName, doubleDataConName :: Name-floatTyConName     = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Float")  floatTyConKey    floatTyCon-floatDataConName   = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "F#")     floatDataConKey  floatDataCon-doubleTyConName    = mkWiredInTyConName   UserSyntax gHC_TYPES (fsLit "Double") doubleTyConKey   doubleTyCon-doubleDataConName  = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "D#")     doubleDataConKey doubleDataCon---- Any--{--Note [Any types]-~~~~~~~~~~~~~~~~-The type constructor Any,--    type family Any :: k where { }--It has these properties:--  * Note that 'Any' is kind polymorphic since in some program we may-    need to use Any to fill in a type variable of some kind other than *-    (see #959 for examples).  Its kind is thus `forall k. k``.--  * It is defined in module GHC.Types, and exported so that it is-    available to users.  For this reason it's treated like any other-    wired-in type:-      - has a fixed unique, anyTyConKey,-      - lives in the global name cache--  * It is a *closed* type family, with no instances.  This means that-    if   ty :: '(k1, k2)  we add a given coercion-             g :: ty ~ (Fst ty, Snd ty)-    If Any was a *data* type, then we'd get inconsistency because 'ty'-    could be (Any '(k1,k2)) and then we'd have an equality with Any on-    one side and '(,) on the other. See also #9097 and #9636.--  * When instantiated at a lifted type it is inhabited by at least one value,-    namely bottom--  * You can safely coerce any /lifted/ type to Any, and back with unsafeCoerce.--  * It does not claim to be a *data* type, and that's important for-    the code generator, because the code gen may *enter* a data value-    but never enters a function value.--  * It is wired-in so we can easily refer to it where we don't have a name-    environment (e.g. see Rules.matchRule for one example)--  * If (Any k) is the type of a value, it must be a /lifted/ value. So-    if we have (Any @(TYPE rr)) then rr must be 'LiftedRep.  See-    Note [TYPE and RuntimeRep] in TysPrim.  This is a convenient-    invariant, and makes isUnliftedTyCon well-defined; otherwise what-    would (isUnliftedTyCon Any) be?--It's used to instantiate un-constrained type variables after type checking. For-example, 'length' has type--  length :: forall a. [a] -> Int--and the list datacon for the empty list has type--  [] :: forall a. [a]--In order to compose these two terms as @length []@ a type-application is required, but there is no constraint on the-choice.  In this situation GHC uses 'Any',--> length (Any *) ([] (Any *))--Above, we print kinds explicitly, as if with --fprint-explicit-kinds.--The Any tycon used to be quite magic, but we have since been able to-implement it merely with an empty kind polymorphic type family. See #10886 for a-bit of history.--}---anyTyConName :: Name-anyTyConName =-    mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Any") anyTyConKey anyTyCon--anyTyCon :: TyCon-anyTyCon = mkFamilyTyCon anyTyConName binders res_kind Nothing-                         (ClosedSynFamilyTyCon Nothing)-                         Nothing-                         NotInjective-  where-    binders@[kv] = mkTemplateKindTyConBinders [liftedTypeKind]-    res_kind = mkTyVarTy (binderVar kv)--anyTy :: Type-anyTy = mkTyConTy anyTyCon--anyTypeOfKind :: Kind -> Type-anyTypeOfKind kind = mkTyConApp anyTyCon [kind]---- | Make a fake, recovery 'TyCon' from an existing one.--- Used when recovering from errors in type declarations-makeRecoveryTyCon :: TyCon -> TyCon-makeRecoveryTyCon tc-  = mkTcTyCon (tyConName tc)-              bndrs res_kind-              noTcTyConScopedTyVars-              True             -- Fully generalised-              flavour          -- Keep old flavour-  where-    flavour = tyConFlavour tc-    [kv] = mkTemplateKindVars [liftedTypeKind]-    (bndrs, res_kind)-       = case flavour of-           PromotedDataConFlavour -> ([mkNamedTyConBinder Inferred kv], mkTyVarTy kv)-           _ -> (tyConBinders tc, tyConResKind tc)-        -- For data types we have already validated their kind, so it-        -- makes sense to keep it. For promoted data constructors we haven't,-        -- so we recover with kind (forall k. k).  Otherwise consider-        --     data T a where { MkT :: Show a => T a }-        -- If T is for some reason invalid, we don't want to fall over-        -- at (promoted) use-sites of MkT.---- Kinds-typeNatKindConName, typeSymbolKindConName :: Name-typeNatKindConName    = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Nat")    typeNatKindConNameKey    typeNatKindCon-typeSymbolKindConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Symbol") typeSymbolKindConNameKey typeSymbolKindCon--constraintKindTyConName :: Name-constraintKindTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Constraint") constraintKindTyConKey   constraintKindTyCon--liftedTypeKindTyConName :: Name-liftedTypeKindTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "Type") liftedTypeKindTyConKey liftedTypeKindTyCon--runtimeRepTyConName, vecRepDataConName, tupleRepDataConName, sumRepDataConName :: Name-runtimeRepTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "RuntimeRep") runtimeRepTyConKey runtimeRepTyCon-vecRepDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "VecRep") vecRepDataConKey vecRepDataCon-tupleRepDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "TupleRep") tupleRepDataConKey tupleRepDataCon-sumRepDataConName = mkWiredInDataConName UserSyntax gHC_TYPES (fsLit "SumRep") sumRepDataConKey sumRepDataCon---- See Note [Wiring in RuntimeRep]-runtimeRepSimpleDataConNames :: [Name]-runtimeRepSimpleDataConNames-  = zipWith3Lazy mk_special_dc_name-      [ fsLit "LiftedRep", fsLit "UnliftedRep"-      , fsLit "IntRep"-      , fsLit "Int8Rep", fsLit "Int16Rep", fsLit "Int32Rep", fsLit "Int64Rep"-      , fsLit "WordRep"-      , fsLit "Word8Rep", fsLit "Word16Rep", fsLit "Word32Rep", fsLit "Word64Rep"-      , fsLit "AddrRep"-      , fsLit "FloatRep", fsLit "DoubleRep"-      ]-      runtimeRepSimpleDataConKeys-      runtimeRepSimpleDataCons--vecCountTyConName :: Name-vecCountTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "VecCount") vecCountTyConKey vecCountTyCon---- See Note [Wiring in RuntimeRep]-vecCountDataConNames :: [Name]-vecCountDataConNames = zipWith3Lazy mk_special_dc_name-                         [ fsLit "Vec2", fsLit "Vec4", fsLit "Vec8"-                         , fsLit "Vec16", fsLit "Vec32", fsLit "Vec64" ]-                         vecCountDataConKeys-                         vecCountDataCons--vecElemTyConName :: Name-vecElemTyConName = mkWiredInTyConName UserSyntax gHC_TYPES (fsLit "VecElem") vecElemTyConKey vecElemTyCon---- See Note [Wiring in RuntimeRep]-vecElemDataConNames :: [Name]-vecElemDataConNames = zipWith3Lazy mk_special_dc_name-                        [ fsLit "Int8ElemRep", fsLit "Int16ElemRep", fsLit "Int32ElemRep"-                        , fsLit "Int64ElemRep", fsLit "Word8ElemRep", fsLit "Word16ElemRep"-                        , fsLit "Word32ElemRep", fsLit "Word64ElemRep"-                        , fsLit "FloatElemRep", fsLit "DoubleElemRep" ]-                        vecElemDataConKeys-                        vecElemDataCons--mk_special_dc_name :: FastString -> Unique -> DataCon -> Name-mk_special_dc_name fs u dc = mkWiredInDataConName UserSyntax gHC_TYPES fs u dc--boolTyCon_RDR, false_RDR, true_RDR, intTyCon_RDR, charTyCon_RDR,-    intDataCon_RDR, listTyCon_RDR, consDataCon_RDR :: RdrName-boolTyCon_RDR   = nameRdrName boolTyConName-false_RDR       = nameRdrName falseDataConName-true_RDR        = nameRdrName trueDataConName-intTyCon_RDR    = nameRdrName intTyConName-charTyCon_RDR   = nameRdrName charTyConName-intDataCon_RDR  = nameRdrName intDataConName-listTyCon_RDR   = nameRdrName listTyConName-consDataCon_RDR = nameRdrName consDataConName--{--************************************************************************-*                                                                      *-\subsection{mkWiredInTyCon}-*                                                                      *-************************************************************************--}---- This function assumes that the types it creates have all parameters at--- Representational role, and that there is no kind polymorphism.-pcTyCon :: Name -> Maybe CType -> [TyVar] -> [DataCon] -> TyCon-pcTyCon name cType tyvars cons-  = mkAlgTyCon name-                (mkAnonTyConBinders VisArg tyvars)-                liftedTypeKind-                (map (const Representational) tyvars)-                cType-                []              -- No stupid theta-                (mkDataTyConRhs cons)-                (VanillaAlgTyCon (mkPrelTyConRepName name))-                False           -- Not in GADT syntax--pcDataCon :: Name -> [TyVar] -> [Type] -> TyCon -> DataCon-pcDataCon n univs = pcDataConWithFixity False n univs-                      []    -- no ex_tvs-                      univs -- the univs are precisely the user-written tyvars--pcDataConWithFixity :: Bool      -- ^ declared infix?-                    -> Name      -- ^ datacon name-                    -> [TyVar]   -- ^ univ tyvars-                    -> [TyCoVar] -- ^ ex tycovars-                    -> [TyCoVar] -- ^ user-written tycovars-                    -> [Type]    -- ^ args-                    -> TyCon-                    -> DataCon-pcDataConWithFixity infx n = pcDataConWithFixity' infx n (dataConWorkerUnique (nameUnique n))-                                                  NoRRI--- The Name's unique is the first of two free uniques;--- the first is used for the datacon itself,--- the second is used for the "worker name"------ To support this the mkPreludeDataConUnique function "allocates"--- one DataCon unique per pair of Ints.--pcDataConWithFixity' :: Bool -> Name -> Unique -> RuntimeRepInfo-                     -> [TyVar] -> [TyCoVar] -> [TyCoVar]-                     -> [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-  = data_con-  where-    tag_map = mkTyConTagMap tycon-    -- This constructs the constructor Name to ConTag map once per-    -- constructor, which is quadratic. It's OK here, because it's-    -- only called for wired in data types that don't have a lot of-    -- constructors. It's also likely that GHC will lift tag_map, since-    -- we call pcDataConWithFixity' with static TyCons in the same module.-    -- See Note [Constructor tag allocation] and #14657-    data_con = mkDataCon dc_name declared_infix prom_info-                (map (const no_bang) arg_tys)-                []      -- No labelled fields-                tyvars ex_tyvars-                (mkTyCoVarBinders Specified user_tyvars)-                []      -- No equality spec-                []      -- No theta-                arg_tys (mkTyConApp tycon (mkTyVarTys tyvars))-                rri-                tycon-                (lookupNameEnv_NF tag_map dc_name)-                []      -- No stupid theta-                (mkDataConWorkId wrk_name data_con)-                NoDataConRep    -- Wired-in types are too simple to need wrappers--    no_bang = HsSrcBang NoSourceText NoSrcUnpack NoSrcStrict--    wrk_name = mkDataConWorkerName data_con wrk_key--    prom_info = mkPrelTyConRepName dc_name--mkDataConWorkerName :: DataCon -> Unique -> Name-mkDataConWorkerName data_con wrk_key =-    mkWiredInName modu wrk_occ wrk_key-                  (AnId (dataConWorkId data_con)) UserSyntax-  where-    modu     = ASSERT( isExternalName dc_name )-               nameModule dc_name-    dc_name = dataConName data_con-    dc_occ  = nameOccName dc_name-    wrk_occ = mkDataConWorkerOcc dc_occ---- used for RuntimeRep and friends-pcSpecialDataCon :: Name -> [Type] -> TyCon -> RuntimeRepInfo -> DataCon-pcSpecialDataCon dc_name arg_tys tycon rri-  = pcDataConWithFixity' False dc_name (dataConWorkerUnique (nameUnique dc_name)) rri-                         [] [] [] arg_tys tycon--{--************************************************************************-*                                                                      *-      Kinds-*                                                                      *-************************************************************************--}--typeNatKindCon, typeSymbolKindCon :: TyCon--- data Nat--- data Symbol-typeNatKindCon    = pcTyCon typeNatKindConName    Nothing [] []-typeSymbolKindCon = pcTyCon typeSymbolKindConName Nothing [] []--typeNatKind, typeSymbolKind :: Kind-typeNatKind    = mkTyConTy typeNatKindCon-typeSymbolKind = mkTyConTy typeSymbolKindCon--constraintKindTyCon :: TyCon-constraintKindTyCon = pcTyCon constraintKindTyConName Nothing [] []--liftedTypeKind, typeToTypeKind, constraintKind :: Kind-liftedTypeKind   = tYPE liftedRepTy-typeToTypeKind   = liftedTypeKind `mkVisFunTy` liftedTypeKind-constraintKind   = mkTyConApp constraintKindTyCon []--{--************************************************************************-*                                                                      *-                Stuff for dealing with tuples-*                                                                      *-************************************************************************--Note [How tuples work]  See also Note [Known-key names] in PrelNames-~~~~~~~~~~~~~~~~~~~~~~-* There are three families of tuple TyCons and corresponding-  DataCons, expressed by the type BasicTypes.TupleSort:-    data TupleSort = BoxedTuple | UnboxedTuple | ConstraintTuple--* All three families are AlgTyCons, whose AlgTyConRhs is TupleTyCon--* BoxedTuples-    - A wired-in type-    - Data type declarations in GHC.Tuple-    - The data constructors really have an info table--* UnboxedTuples-    - A wired-in type-    - Have a pretend DataCon, defined in GHC.Prim,-      but no actual declaration and no info table--* ConstraintTuples-    - Are known-key rather than wired-in. Reason: it's awkward to-      have all the superclass selectors wired-in.-    - Declared as classes in GHC.Classes, e.g.-         class (c1,c2) => (c1,c2)-    - Given constraints: the superclasses automatically become available-    - Wanted constraints: there is a built-in instance-         instance (c1,c2) => (c1,c2)-      See TcInteract.matchCTuple-    - Currently just go up to 62; beyond that-      you have to use manual nesting-    - Their OccNames look like (%,,,%), so they can easily be-      distinguished from term tuples.  But (following Haskell) we-      pretty-print saturated constraint tuples with round parens;-      see BasicTypes.tupleParens.--* In quite a lot of places things are restricted just to-  BoxedTuple/UnboxedTuple, and then we used BasicTypes.Boxity to distinguish-  E.g. tupleTyCon has a Boxity argument--* When looking up an OccName in the original-name cache-  (GHC.Iface.Env.lookupOrigNameCache), we spot the tuple OccName to make sure-  we get the right wired-in name.  This guy can't tell the difference-  between BoxedTuple and ConstraintTuple (same OccName!), so tuples-  are not serialised into interface files using OccNames at all.--* Serialization to interface files works via the usual mechanism for known-key-  things: instead of serializing the OccName we just serialize the key. During-  deserialization we lookup the Name associated with the unique with the logic-  in KnownUniques. See Note [Symbol table representation of names] for details.--Note [One-tuples]-~~~~~~~~~~~~~~~~~-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 GHC.HsToCore.Utils.mkSelectorBinds, when-   there is just one binder-Basically it keeps everything uniform.--However the /naming/ of the type/data constructors for one-tuples is a-bit odd:-  3-tuples:  (,,)   (,,)#-  2-tuples:  (,)    (,)#-  1-tuples:  ??-  0-tuples:  ()     ()#--Zero-tuples have used up the logical name. So we use 'Unit' and 'Unit#'-for one-tuples.  So in ghc-prim:GHC.Tuple we see the declarations:-  data ()     = ()-  data Unit a = Unit a-  data (a,b)  = (a,b)--There is no way to write a boxed one-tuple in Haskell, but it can be-created in Template Haskell or in, e.g., `deriving` code. There is-nothing special about one-tuples in Core; in particular, they have no-custom pretty-printing, just using `Unit`.--Note that there is *not* a unary constraint tuple, unlike for other forms of-tuples. See [Ignore unary constraint tuples] in TcHsType for more-details.--See also Note [Flattening one-tuples] in GHC.Core.Make and-Note [Don't flatten tuples from HsSyn] in GHC.Core.Make.---}---- | Built-in syntax isn't "in scope" so these OccNames map to wired-in Names--- with BuiltInSyntax. However, this should only be necessary while resolving--- names produced by Template Haskell splices since we take care to encode--- built-in syntax names specially in interface files. See--- Note [Symbol table representation of names].------ Moreover, there is no need to include names of things that the user can't--- write (e.g. type representation bindings like $tc(,,,)).-isBuiltInOcc_maybe :: OccName -> Maybe Name-isBuiltInOcc_maybe occ =-    case name of-      "[]" -> Just $ choose_ns listTyConName nilDataConName-      ":"    -> Just consDataConName--      -- equality tycon-      "~"    -> Just eqTyConName--      -- function tycon-      "->"   -> Just funTyConName--      -- boxed tuple data/tycon-      "()"    -> Just $ tup_name Boxed 0-      _ | Just rest <- "(" `BS.stripPrefix` name-        , (commas, rest') <- BS.span (==',') rest-        , ")" <- rest'-             -> Just $ tup_name Boxed (1+BS.length commas)--      -- unboxed tuple data/tycon-      "(##)"  -> Just $ tup_name Unboxed 0-      "Unit#" -> Just $ tup_name Unboxed 1-      _ | Just rest <- "(#" `BS.stripPrefix` name-        , (commas, rest') <- BS.span (==',') rest-        , "#)" <- rest'-             -> Just $ tup_name Unboxed (1+BS.length commas)--      -- unboxed sum tycon-      _ | Just rest <- "(#" `BS.stripPrefix` name-        , (pipes, rest') <- BS.span (=='|') rest-        , "#)" <- rest'-             -> Just $ tyConName $ sumTyCon (1+BS.length pipes)--      -- unboxed sum datacon-      _ | Just rest <- "(#" `BS.stripPrefix` name-        , (pipes1, rest') <- BS.span (=='|') rest-        , Just rest'' <- "_" `BS.stripPrefix` rest'-        , (pipes2, rest''') <- BS.span (=='|') rest''-        , "#)" <- rest'''-             -> let arity = BS.length pipes1 + BS.length pipes2 + 1-                    alt = BS.length pipes1 + 1-                in Just $ dataConName $ sumDataCon alt arity-      _ -> Nothing-  where-    name = bytesFS $ occNameFS occ--    choose_ns :: Name -> Name -> Name-    choose_ns tc dc-      | isTcClsNameSpace ns   = tc-      | isDataConNameSpace ns = dc-      | otherwise             = pprPanic "tup_name" (ppr occ)-      where ns = occNameSpace occ--    tup_name boxity arity-      = choose_ns (getName (tupleTyCon   boxity arity))-                  (getName (tupleDataCon boxity arity))--mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName--- No need to cache these, the caching is done in mk_tuple-mkTupleOcc ns Boxed   ar = mkOccName ns (mkBoxedTupleStr   ar)-mkTupleOcc ns Unboxed ar = mkOccName ns (mkUnboxedTupleStr ar)--mkCTupleOcc :: NameSpace -> Arity -> OccName-mkCTupleOcc ns ar = mkOccName ns (mkConstraintTupleStr ar)--mkTupleStr :: Boxity -> Arity -> String-mkTupleStr Boxed   = mkBoxedTupleStr-mkTupleStr Unboxed = mkUnboxedTupleStr--mkBoxedTupleStr :: Arity -> String-mkBoxedTupleStr 0  = "()"-mkBoxedTupleStr 1  = "Unit"   -- See Note [One-tuples]-mkBoxedTupleStr ar = '(' : commas ar ++ ")"--mkUnboxedTupleStr :: Arity -> String-mkUnboxedTupleStr 0  = "(##)"-mkUnboxedTupleStr 1  = "Unit#"  -- See Note [One-tuples]-mkUnboxedTupleStr ar = "(#" ++ commas ar ++ "#)"--mkConstraintTupleStr :: Arity -> String-mkConstraintTupleStr 0  = "(%%)"-mkConstraintTupleStr 1  = "Unit%"   -- See Note [One-tuples]-mkConstraintTupleStr ar = "(%" ++ commas ar ++ "%)"--commas :: Arity -> String-commas ar = take (ar-1) (repeat ',')--cTupleTyConName :: Arity -> Name-cTupleTyConName arity-  = mkExternalName (mkCTupleTyConUnique arity) gHC_CLASSES-                   (mkCTupleOcc tcName arity) noSrcSpan--cTupleTyConNames :: [Name]-cTupleTyConNames = map cTupleTyConName (0 : [2..mAX_CTUPLE_SIZE])--cTupleTyConNameSet :: NameSet-cTupleTyConNameSet = mkNameSet cTupleTyConNames--isCTupleTyConName :: Name -> Bool--- Use Type.isCTupleClass where possible-isCTupleTyConName n- = ASSERT2( isExternalName n, ppr n )-   nameModule n == gHC_CLASSES-   && n `elemNameSet` cTupleTyConNameSet---- | If the given name is that of a constraint tuple, return its arity.--- Note that this is inefficient.-cTupleTyConNameArity_maybe :: Name -> Maybe Arity-cTupleTyConNameArity_maybe n-  | not (isCTupleTyConName n) = Nothing-  | otherwise = fmap adjustArity (n `elemIndex` cTupleTyConNames)-  where-    -- Since `cTupleTyConNames` jumps straight from the `0` to the `2`-    -- case, we have to adjust accordingly our calculated arity.-    adjustArity a = if a > 0 then a + 1 else a--cTupleDataConName :: Arity -> Name-cTupleDataConName arity-  = mkExternalName (mkCTupleDataConUnique arity) gHC_CLASSES-                   (mkCTupleOcc dataName arity) noSrcSpan--cTupleDataConNames :: [Name]-cTupleDataConNames = map cTupleDataConName (0 : [2..mAX_CTUPLE_SIZE])--tupleTyCon :: Boxity -> Arity -> TyCon-tupleTyCon sort i | i > mAX_TUPLE_SIZE = fst (mk_tuple sort i)  -- Build one specially-tupleTyCon Boxed   i = fst (boxedTupleArr   ! i)-tupleTyCon Unboxed i = fst (unboxedTupleArr ! i)--tupleTyConName :: TupleSort -> Arity -> Name-tupleTyConName ConstraintTuple a = cTupleTyConName a-tupleTyConName BoxedTuple      a = tyConName (tupleTyCon Boxed a)-tupleTyConName UnboxedTuple    a = tyConName (tupleTyCon Unboxed a)--promotedTupleDataCon :: Boxity -> Arity -> TyCon-promotedTupleDataCon boxity i = promoteDataCon (tupleDataCon boxity i)--tupleDataCon :: Boxity -> Arity -> DataCon-tupleDataCon sort i | i > mAX_TUPLE_SIZE = snd (mk_tuple sort i)    -- Build one specially-tupleDataCon Boxed   i = snd (boxedTupleArr   ! i)-tupleDataCon Unboxed i = snd (unboxedTupleArr ! i)--boxedTupleArr, unboxedTupleArr :: Array Int (TyCon,DataCon)-boxedTupleArr   = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Boxed   i | i <- [0..mAX_TUPLE_SIZE]]-unboxedTupleArr = listArray (0,mAX_TUPLE_SIZE) [mk_tuple Unboxed i | i <- [0..mAX_TUPLE_SIZE]]---- | Given the TupleRep/SumRep tycon and list of RuntimeReps of the unboxed--- tuple/sum arguments, produces the return kind of an unboxed tuple/sum type--- constructor. @unboxedTupleSumKind [IntRep, LiftedRep] --> TYPE (TupleRep/SumRep--- [IntRep, LiftedRep])@-unboxedTupleSumKind :: TyCon -> [Type] -> Kind-unboxedTupleSumKind tc rr_tys-  = tYPE (mkTyConApp tc [mkPromotedListTy runtimeRepTy rr_tys])---- | Specialization of 'unboxedTupleSumKind' for tuples-unboxedTupleKind :: [Type] -> Kind-unboxedTupleKind = unboxedTupleSumKind tupleRepDataConTyCon--mk_tuple :: Boxity -> Int -> (TyCon,DataCon)-mk_tuple Boxed arity = (tycon, tuple_con)-  where-    tycon = mkTupleTyCon tc_name tc_binders tc_res_kind tc_arity tuple_con-                         BoxedTuple flavour--    tc_binders  = mkTemplateAnonTyConBinders (replicate arity liftedTypeKind)-    tc_res_kind = liftedTypeKind-    tc_arity    = arity-    flavour     = VanillaAlgTyCon (mkPrelTyConRepName tc_name)--    dc_tvs     = binderVars tc_binders-    dc_arg_tys = mkTyVarTys dc_tvs-    tuple_con  = pcDataCon dc_name dc_tvs dc_arg_tys tycon--    boxity  = Boxed-    modu    = gHC_TUPLE-    tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq-                         (ATyCon tycon) BuiltInSyntax-    dc_name = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq-                            (AConLike (RealDataCon tuple_con)) BuiltInSyntax-    tc_uniq = mkTupleTyConUnique   boxity arity-    dc_uniq = mkTupleDataConUnique boxity arity--mk_tuple Unboxed arity = (tycon, tuple_con)-  where-    tycon = mkTupleTyCon tc_name tc_binders tc_res_kind tc_arity tuple_con-                         UnboxedTuple flavour--    -- See Note [Unboxed tuple RuntimeRep vars] in GHC.Core.TyCon-    -- Kind:  forall (k1:RuntimeRep) (k2:RuntimeRep). TYPE k1 -> TYPE k2 -> #-    tc_binders = mkTemplateTyConBinders (replicate arity runtimeRepTy)-                                        (\ks -> map tYPE ks)--    tc_res_kind = unboxedTupleKind rr_tys--    tc_arity    = arity * 2-    flavour     = UnboxedAlgTyCon $ Just (mkPrelTyConRepName tc_name)--    dc_tvs               = binderVars tc_binders-    (rr_tys, dc_arg_tys) = splitAt arity (mkTyVarTys dc_tvs)-    tuple_con            = pcDataCon dc_name dc_tvs dc_arg_tys tycon--    boxity  = Unboxed-    modu    = gHC_PRIM-    tc_name = mkWiredInName modu (mkTupleOcc tcName boxity arity) tc_uniq-                         (ATyCon tycon) BuiltInSyntax-    dc_name = mkWiredInName modu (mkTupleOcc dataName boxity arity) dc_uniq-                            (AConLike (RealDataCon tuple_con)) BuiltInSyntax-    tc_uniq = mkTupleTyConUnique   boxity arity-    dc_uniq = mkTupleDataConUnique boxity arity--unitTyCon :: TyCon-unitTyCon = tupleTyCon Boxed 0--unitTyConKey :: Unique-unitTyConKey = getUnique unitTyCon--unitDataCon :: DataCon-unitDataCon   = head (tyConDataCons unitTyCon)--unitDataConId :: Id-unitDataConId = dataConWorkId unitDataCon--pairTyCon :: TyCon-pairTyCon = tupleTyCon Boxed 2--unboxedUnitTyCon :: TyCon-unboxedUnitTyCon = tupleTyCon Unboxed 0--unboxedUnitDataCon :: DataCon-unboxedUnitDataCon = tupleDataCon   Unboxed 0---{- *********************************************************************-*                                                                      *-      Unboxed sums-*                                                                      *-********************************************************************* -}---- | OccName for n-ary unboxed sum type constructor.-mkSumTyConOcc :: Arity -> OccName-mkSumTyConOcc n = mkOccName tcName str-  where-    -- No need to cache these, the caching is done in mk_sum-    str = '(' : '#' : bars ++ "#)"-    bars = replicate (n-1) '|'---- | OccName for i-th alternative of n-ary unboxed sum data constructor.-mkSumDataConOcc :: ConTag -> Arity -> OccName-mkSumDataConOcc alt n = mkOccName dataName str-  where-    -- No need to cache these, the caching is done in mk_sum-    str = '(' : '#' : bars alt ++ '_' : bars (n - alt - 1) ++ "#)"-    bars i = replicate i '|'---- | Type constructor for n-ary unboxed sum.-sumTyCon :: Arity -> TyCon-sumTyCon arity-  | arity > mAX_SUM_SIZE-  = fst (mk_sum arity)  -- Build one specially--  | arity < 2-  = panic ("sumTyCon: Arity starts from 2. (arity: " ++ show arity ++ ")")--  | otherwise-  = fst (unboxedSumArr ! arity)---- | Data constructor for i-th alternative of a n-ary unboxed sum.-sumDataCon :: ConTag -- Alternative-           -> Arity  -- Arity-           -> DataCon-sumDataCon alt arity-  | alt > arity-  = panic ("sumDataCon: index out of bounds: alt: "-           ++ show alt ++ " > arity " ++ show arity)--  | alt <= 0-  = panic ("sumDataCon: Alts start from 1. (alt: " ++ show alt-           ++ ", arity: " ++ show arity ++ ")")--  | arity < 2-  = panic ("sumDataCon: Arity starts from 2. (alt: " ++ show alt-           ++ ", arity: " ++ show arity ++ ")")--  | arity > mAX_SUM_SIZE-  = snd (mk_sum arity) ! (alt - 1)  -- Build one specially--  | otherwise-  = snd (unboxedSumArr ! arity) ! (alt - 1)---- | Cached type and data constructors for sums. The outer array is--- indexed by the arity of the sum and the inner array is indexed by--- the alternative.-unboxedSumArr :: Array Int (TyCon, Array Int DataCon)-unboxedSumArr = listArray (2,mAX_SUM_SIZE) [mk_sum i | i <- [2..mAX_SUM_SIZE]]---- | Specialization of 'unboxedTupleSumKind' for sums-unboxedSumKind :: [Type] -> Kind-unboxedSumKind = unboxedTupleSumKind sumRepDataConTyCon---- | Create type constructor and data constructors for n-ary unboxed sum.-mk_sum :: Arity -> (TyCon, Array ConTagZ DataCon)-mk_sum arity = (tycon, sum_cons)-  where-    tycon   = mkSumTyCon tc_name tc_binders tc_res_kind (arity * 2) tyvars (elems sum_cons)-                         (UnboxedAlgTyCon rep_name)--    -- Unboxed sums are currently not Typeable due to efficiency concerns. See #13276.-    rep_name = Nothing -- Just $ mkPrelTyConRepName tc_name--    tc_binders = mkTemplateTyConBinders (replicate arity runtimeRepTy)-                                        (\ks -> map tYPE ks)--    tyvars = binderVars tc_binders--    tc_res_kind = unboxedSumKind rr_tys--    (rr_tys, tyvar_tys) = splitAt arity (mkTyVarTys tyvars)--    tc_name = mkWiredInName gHC_PRIM (mkSumTyConOcc arity) tc_uniq-                            (ATyCon tycon) BuiltInSyntax--    sum_cons = listArray (0,arity-1) [sum_con i | i <- [0..arity-1]]-    sum_con i = let dc = pcDataCon dc_name-                                   tyvars -- univ tyvars-                                   [tyvar_tys !! i] -- arg types-                                   tycon--                    dc_name = mkWiredInName gHC_PRIM-                                            (mkSumDataConOcc i arity)-                                            (dc_uniq i)-                                            (AConLike (RealDataCon dc))-                                            BuiltInSyntax-                in dc--    tc_uniq   = mkSumTyConUnique   arity-    dc_uniq i = mkSumDataConUnique i arity--{--************************************************************************-*                                                                      *-              Equality types and classes-*                                                                      *-********************************************************************* -}---- See Note [The equality types story] in TysPrim--- ((~~) :: forall k1 k2 (a :: k1) (b :: k2). a -> b -> Constraint)------ It's tempting to put functional dependencies on (~~), but it's not--- necessary because the functional-dependency coverage check looks--- through superclasses, and (~#) is handled in that check.--eqTyCon,   heqTyCon,   coercibleTyCon   :: TyCon-eqClass,   heqClass,   coercibleClass   :: Class-eqDataCon, heqDataCon, coercibleDataCon :: DataCon-eqSCSelId, heqSCSelId, coercibleSCSelId :: Id--(eqTyCon, eqClass, eqDataCon, eqSCSelId)-  = (tycon, klass, datacon, sc_sel_id)-  where-    tycon     = mkClassTyCon eqTyConName binders roles-                             rhs klass-                             (mkPrelTyConRepName eqTyConName)-    klass     = mk_class tycon sc_pred sc_sel_id-    datacon   = pcDataCon eqDataConName tvs [sc_pred] tycon--    -- Kind: forall k. k -> k -> Constraint-    binders   = mkTemplateTyConBinders [liftedTypeKind] (\[k] -> [k,k])-    roles     = [Nominal, Nominal, Nominal]-    rhs       = mkDataTyConRhs [datacon]--    tvs@[k,a,b] = binderVars binders-    sc_pred     = mkTyConApp eqPrimTyCon (mkTyVarTys [k,k,a,b])-    sc_sel_id   = mkDictSelId eqSCSelIdName klass--(heqTyCon, heqClass, heqDataCon, heqSCSelId)-  = (tycon, klass, datacon, sc_sel_id)-  where-    tycon     = mkClassTyCon heqTyConName binders roles-                             rhs klass-                             (mkPrelTyConRepName heqTyConName)-    klass     = mk_class tycon sc_pred sc_sel_id-    datacon   = pcDataCon heqDataConName tvs [sc_pred] tycon--    -- Kind: forall k1 k2. k1 -> k2 -> Constraint-    binders   = mkTemplateTyConBinders [liftedTypeKind, liftedTypeKind] id-    roles     = [Nominal, Nominal, Nominal, Nominal]-    rhs       = mkDataTyConRhs [datacon]--    tvs       = binderVars binders-    sc_pred   = mkTyConApp eqPrimTyCon (mkTyVarTys tvs)-    sc_sel_id = mkDictSelId heqSCSelIdName klass--(coercibleTyCon, coercibleClass, coercibleDataCon, coercibleSCSelId)-  = (tycon, klass, datacon, sc_sel_id)-  where-    tycon     = mkClassTyCon coercibleTyConName binders roles-                             rhs klass-                             (mkPrelTyConRepName coercibleTyConName)-    klass     = mk_class tycon sc_pred sc_sel_id-    datacon   = pcDataCon coercibleDataConName tvs [sc_pred] tycon--    -- Kind: forall k. k -> k -> Constraint-    binders   = mkTemplateTyConBinders [liftedTypeKind] (\[k] -> [k,k])-    roles     = [Nominal, Representational, Representational]-    rhs       = mkDataTyConRhs [datacon]--    tvs@[k,a,b] = binderVars binders-    sc_pred     = mkTyConApp eqReprPrimTyCon (mkTyVarTys [k, k, a, b])-    sc_sel_id   = mkDictSelId coercibleSCSelIdName klass--mk_class :: TyCon -> PredType -> Id -> Class-mk_class tycon sc_pred sc_sel_id-  = mkClass (tyConName tycon) (tyConTyVars tycon) [] [sc_pred] [sc_sel_id]-            [] [] (mkAnd []) tycon----{- *********************************************************************-*                                                                      *-                Kinds and RuntimeRep-*                                                                      *-********************************************************************* -}---- For information about the usage of the following type,--- see Note [TYPE and RuntimeRep] in module TysPrim-runtimeRepTy :: Type-runtimeRepTy = mkTyConTy runtimeRepTyCon---- Type synonyms; see Note [TYPE and RuntimeRep] in TysPrim--- type Type = tYPE 'LiftedRep-liftedTypeKindTyCon :: TyCon-liftedTypeKindTyCon   = buildSynTyCon liftedTypeKindTyConName-                                       [] liftedTypeKind []-                                       (tYPE liftedRepTy)--runtimeRepTyCon :: TyCon-runtimeRepTyCon = pcTyCon runtimeRepTyConName Nothing []-                          (vecRepDataCon : tupleRepDataCon :-                           sumRepDataCon : runtimeRepSimpleDataCons)--vecRepDataCon :: DataCon-vecRepDataCon = pcSpecialDataCon vecRepDataConName [ mkTyConTy vecCountTyCon-                                                   , mkTyConTy vecElemTyCon ]-                                 runtimeRepTyCon-                                 (RuntimeRep prim_rep_fun)-  where-    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType-    prim_rep_fun [count, elem]-      | VecCount n <- tyConRuntimeRepInfo (tyConAppTyCon count)-      , VecElem  e <- tyConRuntimeRepInfo (tyConAppTyCon elem)-      = [VecRep n e]-    prim_rep_fun args-      = pprPanic "vecRepDataCon" (ppr args)--vecRepDataConTyCon :: TyCon-vecRepDataConTyCon = promoteDataCon vecRepDataCon--tupleRepDataCon :: DataCon-tupleRepDataCon = pcSpecialDataCon tupleRepDataConName [ mkListTy runtimeRepTy ]-                                   runtimeRepTyCon (RuntimeRep prim_rep_fun)-  where-    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType-    prim_rep_fun [rr_ty_list]-      = concatMap (runtimeRepPrimRep doc) rr_tys-      where-        rr_tys = extractPromotedList rr_ty_list-        doc    = text "tupleRepDataCon" <+> ppr rr_tys-    prim_rep_fun args-      = pprPanic "tupleRepDataCon" (ppr args)--tupleRepDataConTyCon :: TyCon-tupleRepDataConTyCon = promoteDataCon tupleRepDataCon--sumRepDataCon :: DataCon-sumRepDataCon = pcSpecialDataCon sumRepDataConName [ mkListTy runtimeRepTy ]-                                 runtimeRepTyCon (RuntimeRep prim_rep_fun)-  where-    -- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType-    prim_rep_fun [rr_ty_list]-      = map slotPrimRep (ubxSumRepType prim_repss)-      where-        rr_tys     = extractPromotedList rr_ty_list-        doc        = text "sumRepDataCon" <+> ppr rr_tys-        prim_repss = map (runtimeRepPrimRep doc) rr_tys-    prim_rep_fun args-      = pprPanic "sumRepDataCon" (ppr args)--sumRepDataConTyCon :: TyCon-sumRepDataConTyCon = promoteDataCon sumRepDataCon---- See Note [Wiring in RuntimeRep]--- See Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType-runtimeRepSimpleDataCons :: [DataCon]-liftedRepDataCon :: DataCon-runtimeRepSimpleDataCons@(liftedRepDataCon : _)-  = zipWithLazy mk_runtime_rep_dc-    [ LiftedRep, UnliftedRep-    , IntRep-    , Int8Rep, Int16Rep, Int32Rep, Int64Rep-    , WordRep-    , Word8Rep, Word16Rep, Word32Rep, Word64Rep-    , AddrRep-    , FloatRep, DoubleRep-    ]-    runtimeRepSimpleDataConNames-  where-    mk_runtime_rep_dc primrep name-      = pcSpecialDataCon name [] runtimeRepTyCon (RuntimeRep (\_ -> [primrep]))---- See Note [Wiring in RuntimeRep]-liftedRepDataConTy, unliftedRepDataConTy,-  intRepDataConTy,-  int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,-  wordRepDataConTy,-  word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,-  addrRepDataConTy,-  floatRepDataConTy, doubleRepDataConTy :: Type-[liftedRepDataConTy, unliftedRepDataConTy,-   intRepDataConTy,-   int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,-   wordRepDataConTy,-   word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,-   addrRepDataConTy,-   floatRepDataConTy, doubleRepDataConTy-   ]-  = map (mkTyConTy . promoteDataCon) runtimeRepSimpleDataCons--vecCountTyCon :: TyCon-vecCountTyCon = pcTyCon vecCountTyConName Nothing [] vecCountDataCons---- See Note [Wiring in RuntimeRep]-vecCountDataCons :: [DataCon]-vecCountDataCons = zipWithLazy mk_vec_count_dc-                     [ 2, 4, 8, 16, 32, 64 ]-                     vecCountDataConNames-  where-    mk_vec_count_dc n name-      = pcSpecialDataCon name [] vecCountTyCon (VecCount n)---- See Note [Wiring in RuntimeRep]-vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,-  vec64DataConTy :: Type-[vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,-  vec64DataConTy] = map (mkTyConTy . promoteDataCon) vecCountDataCons--vecElemTyCon :: TyCon-vecElemTyCon = pcTyCon vecElemTyConName Nothing [] vecElemDataCons---- See Note [Wiring in RuntimeRep]-vecElemDataCons :: [DataCon]-vecElemDataCons = zipWithLazy mk_vec_elem_dc-                    [ Int8ElemRep, Int16ElemRep, Int32ElemRep, Int64ElemRep-                    , Word8ElemRep, Word16ElemRep, Word32ElemRep, Word64ElemRep-                    , FloatElemRep, DoubleElemRep ]-                    vecElemDataConNames-  where-    mk_vec_elem_dc elem name-      = pcSpecialDataCon name [] vecElemTyCon (VecElem elem)---- See Note [Wiring in RuntimeRep]-int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,-  int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,-  word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,-  doubleElemRepDataConTy :: Type-[int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,-  int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,-  word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,-  doubleElemRepDataConTy] = map (mkTyConTy . promoteDataCon)-                                vecElemDataCons--liftedRepDataConTyCon :: TyCon-liftedRepDataConTyCon = promoteDataCon liftedRepDataCon---- The type ('LiftedRep)-liftedRepTy :: Type-liftedRepTy = liftedRepDataConTy--{- *********************************************************************-*                                                                      *-     The boxed primitive types: Char, Int, etc-*                                                                      *-********************************************************************* -}--boxingDataCon_maybe :: TyCon -> Maybe DataCon---    boxingDataCon_maybe Char# = C#---    boxingDataCon_maybe Int#  = I#---    ... etc ...--- See Note [Boxing primitive types]-boxingDataCon_maybe tc-  = lookupNameEnv boxing_constr_env (tyConName tc)--boxing_constr_env :: NameEnv DataCon-boxing_constr_env-  = mkNameEnv [(charPrimTyConName  , charDataCon  )-              ,(intPrimTyConName   , intDataCon   )-              ,(wordPrimTyConName  , wordDataCon  )-              ,(floatPrimTyConName , floatDataCon )-              ,(doublePrimTyConName, doubleDataCon) ]--{- Note [Boxing primitive types]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-For a handful of primitive types (Int, Char, Word, Float, Double),-we can readily box and an unboxed version (Int#, Char# etc) using-the corresponding data constructor.  This is useful in a couple-of places, notably let-floating -}---charTy :: Type-charTy = mkTyConTy charTyCon--charTyCon :: TyCon-charTyCon   = pcTyCon charTyConName-                   (Just (CType NoSourceText Nothing-                                  (NoSourceText,fsLit "HsChar")))-                   [] [charDataCon]-charDataCon :: DataCon-charDataCon = pcDataCon charDataConName [] [charPrimTy] charTyCon--stringTy :: Type-stringTy = mkListTy charTy -- convenience only--intTy :: Type-intTy = mkTyConTy intTyCon--intTyCon :: TyCon-intTyCon = pcTyCon intTyConName-               (Just (CType NoSourceText Nothing (NoSourceText,fsLit "HsInt")))-                 [] [intDataCon]-intDataCon :: DataCon-intDataCon = pcDataCon intDataConName [] [intPrimTy] intTyCon--wordTy :: Type-wordTy = mkTyConTy wordTyCon--wordTyCon :: TyCon-wordTyCon = pcTyCon wordTyConName-            (Just (CType NoSourceText Nothing (NoSourceText, fsLit "HsWord")))-               [] [wordDataCon]-wordDataCon :: DataCon-wordDataCon = pcDataCon wordDataConName [] [wordPrimTy] wordTyCon--word8Ty :: Type-word8Ty = mkTyConTy word8TyCon--word8TyCon :: TyCon-word8TyCon = pcTyCon word8TyConName-                     (Just (CType NoSourceText Nothing-                            (NoSourceText, fsLit "HsWord8"))) []-                     [word8DataCon]-word8DataCon :: DataCon-word8DataCon = pcDataCon word8DataConName [] [wordPrimTy] word8TyCon--floatTy :: Type-floatTy = mkTyConTy floatTyCon--floatTyCon :: TyCon-floatTyCon   = pcTyCon floatTyConName-                      (Just (CType NoSourceText Nothing-                             (NoSourceText, fsLit "HsFloat"))) []-                      [floatDataCon]-floatDataCon :: DataCon-floatDataCon = pcDataCon         floatDataConName [] [floatPrimTy] floatTyCon--doubleTy :: Type-doubleTy = mkTyConTy doubleTyCon--doubleTyCon :: TyCon-doubleTyCon = pcTyCon doubleTyConName-                      (Just (CType NoSourceText Nothing-                             (NoSourceText,fsLit "HsDouble"))) []-                      [doubleDataCon]--doubleDataCon :: DataCon-doubleDataCon = pcDataCon doubleDataConName [] [doublePrimTy] doubleTyCon--{--************************************************************************-*                                                                      *-              The Bool type-*                                                                      *-************************************************************************--An ordinary enumeration type, but deeply wired in.  There are no-magical operations on @Bool@ (just the regular Prelude code).--{\em BEGIN IDLE SPECULATION BY SIMON}--This is not the only way to encode @Bool@.  A more obvious coding makes-@Bool@ just a boxed up version of @Bool#@, like this:-\begin{verbatim}-type Bool# = Int#-data Bool = MkBool Bool#-\end{verbatim}--Unfortunately, this doesn't correspond to what the Report says @Bool@-looks like!  Furthermore, we get slightly less efficient code (I-think) with this coding. @gtInt@ would look like this:--\begin{verbatim}-gtInt :: Int -> Int -> Bool-gtInt x y = case x of I# x# ->-            case y of I# y# ->-            case (gtIntPrim x# y#) of-                b# -> MkBool b#-\end{verbatim}--Notice that the result of the @gtIntPrim@ comparison has to be turned-into an integer (here called @b#@), and returned in a @MkBool@ box.--The @if@ expression would compile to this:-\begin{verbatim}-case (gtInt x y) of-  MkBool b# -> case b# of { 1# -> e1; 0# -> e2 }-\end{verbatim}--I think this code is a little less efficient than the previous code,-but I'm not certain.  At all events, corresponding with the Report is-important.  The interesting thing is that the language is expressive-enough to describe more than one alternative; and that a type doesn't-necessarily need to be a straightforwardly boxed version of its-primitive counterpart.--{\em END IDLE SPECULATION BY SIMON}--}--boolTy :: Type-boolTy = mkTyConTy boolTyCon--boolTyCon :: TyCon-boolTyCon = pcTyCon boolTyConName-                    (Just (CType NoSourceText Nothing-                           (NoSourceText, fsLit "HsBool")))-                    [] [falseDataCon, trueDataCon]--falseDataCon, trueDataCon :: DataCon-falseDataCon = pcDataCon falseDataConName [] [] boolTyCon-trueDataCon  = pcDataCon trueDataConName  [] [] boolTyCon--falseDataConId, trueDataConId :: Id-falseDataConId = dataConWorkId falseDataCon-trueDataConId  = dataConWorkId trueDataCon--orderingTyCon :: TyCon-orderingTyCon = pcTyCon orderingTyConName Nothing-                        [] [ordLTDataCon, ordEQDataCon, ordGTDataCon]--ordLTDataCon, ordEQDataCon, ordGTDataCon :: DataCon-ordLTDataCon = pcDataCon ordLTDataConName  [] [] orderingTyCon-ordEQDataCon = pcDataCon ordEQDataConName  [] [] orderingTyCon-ordGTDataCon = pcDataCon ordGTDataConName  [] [] orderingTyCon--ordLTDataConId, ordEQDataConId, ordGTDataConId :: Id-ordLTDataConId = dataConWorkId ordLTDataCon-ordEQDataConId = dataConWorkId ordEQDataCon-ordGTDataConId = dataConWorkId ordGTDataCon--{--************************************************************************-*                                                                      *-            The List type-   Special syntax, deeply wired in,-   but otherwise an ordinary algebraic data type-*                                                                      *-************************************************************************--       data [] a = [] | a : (List a)--}--mkListTy :: Type -> Type-mkListTy ty = mkTyConApp listTyCon [ty]--listTyCon :: TyCon-listTyCon = pcTyCon listTyConName Nothing [alphaTyVar] [nilDataCon, consDataCon]---- See also Note [Empty lists] in GHC.Hs.Expr.-nilDataCon :: DataCon-nilDataCon  = pcDataCon nilDataConName alpha_tyvar [] listTyCon--consDataCon :: DataCon-consDataCon = pcDataConWithFixity True {- Declared infix -}-               consDataConName-               alpha_tyvar [] alpha_tyvar-               [alphaTy, mkTyConApp listTyCon alpha_ty] listTyCon--- Interesting: polymorphic recursion would help here.--- We can't use (mkListTy alphaTy) in the defn of consDataCon, else mkListTy--- gets the over-specific type (Type -> Type)---- Wired-in type Maybe--maybeTyCon :: TyCon-maybeTyCon = pcTyCon maybeTyConName Nothing alpha_tyvar-                     [nothingDataCon, justDataCon]--nothingDataCon :: DataCon-nothingDataCon = pcDataCon nothingDataConName alpha_tyvar [] maybeTyCon--justDataCon :: DataCon-justDataCon = pcDataCon justDataConName alpha_tyvar [alphaTy] maybeTyCon--{--** *********************************************************************-*                                                                      *-            The tuple types-*                                                                      *-************************************************************************--The tuple types are definitely magic, because they form an infinite-family.--\begin{itemize}-\item-They have a special family of type constructors, of type @TyCon@-These contain the tycon arity, but don't require a Unique.--\item-They have a special family of constructors, of type-@Id@. Again these contain their arity but don't need a Unique.--\item-There should be a magic way of generating the info tables and-entry code for all tuples.--But at the moment we just compile a Haskell source-file\srcloc{lib/prelude/...} containing declarations like:-\begin{verbatim}-data Tuple0             = Tup0-data Tuple2  a b        = Tup2  a b-data Tuple3  a b c      = Tup3  a b c-data Tuple4  a b c d    = Tup4  a b c d-...-\end{verbatim}-The print-names associated with the magic @Id@s for tuple constructors-``just happen'' to be the same as those generated by these-declarations.--\item-The instance environment should have a magic way to know-that each tuple type is an instances of classes @Eq@, @Ix@, @Ord@ and-so on. \ToDo{Not implemented yet.}--\item-There should also be a way to generate the appropriate code for each-of these instances, but (like the info tables and entry code) it is-done by enumeration\srcloc{lib/prelude/InTup?.hs}.-\end{itemize}--}---- | Make a tuple type. The list of types should /not/ include any--- RuntimeRep specifications. Boxed 1-tuples are flattened.--- See Note [One-tuples]-mkTupleTy :: Boxity -> [Type] -> Type--- Special case for *boxed* 1-tuples, which are represented by the type itself-mkTupleTy Boxed   [ty] = ty-mkTupleTy boxity  tys  = mkTupleTy1 boxity tys---- | 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 GHC.Core.Make-mkTupleTy1 :: Boxity -> [Type] -> Type-mkTupleTy1 Boxed   tys  = mkTyConApp (tupleTyCon Boxed (length tys)) tys-mkTupleTy1 Unboxed tys  = mkTyConApp (tupleTyCon Unboxed (length tys))-                                         (map getRuntimeRep tys ++ tys)---- | Build the type of a small tuple that holds the specified type of thing--- Flattens 1-tuples. See Note [One-tuples].-mkBoxedTupleTy :: [Type] -> Type-mkBoxedTupleTy tys = mkTupleTy Boxed tys--unitTy :: Type-unitTy = mkTupleTy Boxed []--{- *********************************************************************-*                                                                      *-            The sum types-*                                                                      *-************************************************************************--}--mkSumTy :: [Type] -> Type-mkSumTy tys = mkTyConApp (sumTyCon (length tys))-                         (map getRuntimeRep tys ++ tys)---- Promoted Booleans--promotedFalseDataCon, promotedTrueDataCon :: TyCon-promotedTrueDataCon   = promoteDataCon trueDataCon-promotedFalseDataCon  = promoteDataCon falseDataCon---- Promoted Maybe-promotedNothingDataCon, promotedJustDataCon :: TyCon-promotedNothingDataCon = promoteDataCon nothingDataCon-promotedJustDataCon    = promoteDataCon justDataCon---- Promoted Ordering--promotedLTDataCon-  , promotedEQDataCon-  , promotedGTDataCon-  :: TyCon-promotedLTDataCon     = promoteDataCon ordLTDataCon-promotedEQDataCon     = promoteDataCon ordEQDataCon-promotedGTDataCon     = promoteDataCon ordGTDataCon---- Promoted List-promotedConsDataCon, promotedNilDataCon :: TyCon-promotedConsDataCon   = promoteDataCon consDataCon-promotedNilDataCon    = promoteDataCon nilDataCon---- | Make a *promoted* list.-mkPromotedListTy :: Kind   -- ^ of the elements of the list-                 -> [Type] -- ^ elements-                 -> Type-mkPromotedListTy k tys-  = foldr cons nil tys-  where-    cons :: Type  -- element-         -> Type  -- list-         -> Type-    cons elt list = mkTyConApp promotedConsDataCon [k, elt, list]--    nil :: Type-    nil = mkTyConApp promotedNilDataCon [k]---- | Extract the elements of a promoted list. Panics if the type is not a--- promoted list-extractPromotedList :: Type    -- ^ The promoted list-                    -> [Type]-extractPromotedList tys = go tys-  where-    go list_ty-      | Just (tc, [_k, t, ts]) <- splitTyConApp_maybe list_ty-      = ASSERT( tc `hasKey` consDataConKey )-        t : go ts--      | Just (tc, [_k]) <- splitTyConApp_maybe list_ty-      = ASSERT( tc `hasKey` nilDataConKey )-        []--      | otherwise-      = pprPanic "extractPromotedList" (ppr tys)
− compiler/prelude/TysWiredIn.hs-boot 
@@ -1,47 +0,0 @@-module TysWiredIn where--import {-# SOURCE #-} GHC.Core.TyCon    ( TyCon )-import {-# SOURCE #-} GHC.Core.TyCo.Rep (Type, Kind)--import GHC.Types.Basic (Arity, TupleSort)-import GHC.Types.Name (Name)--listTyCon :: TyCon-typeNatKind, typeSymbolKind :: Type-mkBoxedTupleTy :: [Type] -> Type--coercibleTyCon, heqTyCon :: TyCon--unitTy :: Type--liftedTypeKind :: Kind-liftedTypeKindTyCon :: TyCon--constraintKind :: Kind--runtimeRepTyCon, vecCountTyCon, vecElemTyCon :: TyCon-runtimeRepTy :: Type--liftedRepDataConTyCon, vecRepDataConTyCon, tupleRepDataConTyCon :: TyCon--liftedRepDataConTy, unliftedRepDataConTy,-  intRepDataConTy,-  int8RepDataConTy, int16RepDataConTy, int32RepDataConTy, int64RepDataConTy,-  wordRepDataConTy,-  word8RepDataConTy, word16RepDataConTy, word32RepDataConTy, word64RepDataConTy,-  addrRepDataConTy,-  floatRepDataConTy, doubleRepDataConTy :: Type--vec2DataConTy, vec4DataConTy, vec8DataConTy, vec16DataConTy, vec32DataConTy,-  vec64DataConTy :: Type--int8ElemRepDataConTy, int16ElemRepDataConTy, int32ElemRepDataConTy,-  int64ElemRepDataConTy, word8ElemRepDataConTy, word16ElemRepDataConTy,-  word32ElemRepDataConTy, word64ElemRepDataConTy, floatElemRepDataConTy,-  doubleElemRepDataConTy :: Type--anyTypeOfKind :: Kind -> Type-unboxedTupleKind :: [Type] -> Type-mkPromotedListTy :: Type -> [Type] -> Type--tupleTyConName :: TupleSort -> Arity -> Name
− compiler/typecheck/Constraint.hs 
@@ -1,1819 +0,0 @@-{---This module defines types and simple operations over constraints,-as used in the type-checker and constraint solver.---}--{-# LANGUAGE CPP, GeneralizedNewtypeDeriving #-}--{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}--module Constraint (-        -- QCInst-        QCInst(..), isPendingScInst,--        -- Canonical constraints-        Xi, Ct(..), Cts, CtIrredStatus(..), emptyCts, andCts, andManyCts, pprCts,-        singleCt, listToCts, ctsElts, consCts, snocCts, extendCtsList,-        isEmptyCts, isCTyEqCan, isCFunEqCan,-        isPendingScDict, superClassesMightHelp, getPendingWantedScs,-        isCDictCan_Maybe, isCFunEqCan_maybe,-        isCNonCanonical, isWantedCt, isDerivedCt,-        isGivenCt, isHoleCt, isOutOfScopeCt, isExprHoleCt, isTypeHoleCt,-        isUserTypeErrorCt, getUserTypeErrorMsg,-        ctEvidence, ctLoc, setCtLoc, ctPred, ctFlavour, ctEqRel, ctOrigin,-        ctEvId, mkTcEqPredLikeEv,-        mkNonCanonical, mkNonCanonicalCt, mkGivens,-        mkIrredCt,-        ctEvPred, ctEvLoc, ctEvOrigin, ctEvEqRel,-        ctEvExpr, ctEvTerm, ctEvCoercion, ctEvEvId,-        tyCoVarsOfCt, tyCoVarsOfCts,-        tyCoVarsOfCtList, tyCoVarsOfCtsList,--        WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,-        isSolvedWC, andWC, unionsWC, mkSimpleWC, mkImplicWC,-        addInsols, insolublesOnly, addSimples, addImplics,-        tyCoVarsOfWC, dropDerivedWC, dropDerivedSimples,-        tyCoVarsOfWCList, insolubleCt, insolubleEqCt,-        isDroppableCt, insolubleImplic,-        arisesFromGivens,--        Implication(..), implicationPrototype,-        ImplicStatus(..), isInsolubleStatus, isSolvedStatus,-        SubGoalDepth, initialSubGoalDepth, maxSubGoalDepth,-        bumpSubGoalDepth, subGoalDepthExceeded,-        CtLoc(..), ctLocSpan, ctLocEnv, ctLocLevel, ctLocOrigin,-        ctLocTypeOrKind_maybe,-        ctLocDepth, bumpCtLocDepth, isGivenLoc,-        setCtLocOrigin, updateCtLocOrigin, setCtLocEnv, setCtLocSpan,-        pprCtLoc,--        -- CtEvidence-        CtEvidence(..), TcEvDest(..),-        mkKindLoc, toKindLoc, mkGivenLoc,-        isWanted, isGiven, isDerived, isGivenOrWDeriv,-        ctEvRole,--        wrapType,--        CtFlavour(..), ShadowInfo(..), ctEvFlavour,-        CtFlavourRole, ctEvFlavourRole, ctFlavourRole,-        eqCanRewrite, eqCanRewriteFR, eqMayRewriteFR,-        eqCanDischargeFR,-        funEqCanDischarge, funEqCanDischargeF,--        -- Pretty printing-        pprEvVarTheta,-        pprEvVars, pprEvVarWithType,--        -- holes-        HoleSort(..),--  )-  where--#include "HsVersions.h"--import GhcPrelude--import {-# SOURCE #-} TcRnTypes ( TcLclEnv, setLclEnvTcLevel, getLclEnvTcLevel-                                , setLclEnvLoc, getLclEnvLoc )--import GHC.Core.Predicate-import GHC.Core.Type-import GHC.Core.Coercion-import GHC.Core.Class-import GHC.Core.TyCon-import GHC.Types.Var--import TcType-import TcEvidence-import TcOrigin--import GHC.Core--import GHC.Core.TyCo.Ppr-import GHC.Types.Name.Occurrence-import FV-import GHC.Types.Var.Set-import GHC.Driver.Session-import GHC.Types.Basic--import Outputable-import GHC.Types.SrcLoc-import Bag-import Util--import Control.Monad ( msum )--{--************************************************************************-*                                                                      *-*                       Canonical constraints                          *-*                                                                      *-*   These are the constraints the low-level simplifier works with      *-*                                                                      *-************************************************************************--}---- The syntax of xi (ξ) types:--- xi ::= a | T xis | xis -> xis | ... | forall a. tau--- Two important notes:---      (i) No type families, unless we are under a ForAll---      (ii) Note that xi types can contain unexpanded type synonyms;---           however, the (transitive) expansions of those type synonyms---           will not contain any type functions, unless we are under a ForAll.--- We enforce the structure of Xi types when we flatten (TcCanonical)--type Xi = Type       -- In many comments, "xi" ranges over Xi--type Cts = Bag Ct--data Ct-  -- Atomic canonical constraints-  = CDictCan {  -- e.g.  Num xi-      cc_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]--      cc_class  :: Class,-      cc_tyargs :: [Xi],   -- cc_tyargs are function-free, hence Xi--      cc_pend_sc :: Bool   -- See Note [The superclass story] in TcCanonical-                           -- True <=> (a) cc_class has superclasses-                           --          (b) we have not (yet) added those-                           --              superclasses as Givens-    }--  | CIrredCan {  -- These stand for yet-unusable predicates-      cc_ev     :: CtEvidence,   -- See Note [Ct/evidence invariant]-      cc_status :: CtIrredStatus--        -- For the might-be-soluble case, the ctev_pred of the evidence is-        -- of form   (tv xi1 xi2 ... xin)   with a tyvar at the head-        --      or   (tv1 ~ ty2)   where the CTyEqCan  kind invariant (TyEq:K) fails-        --      or   (F tys ~ ty)  where the CFunEqCan kind invariant fails-        -- See Note [CIrredCan constraints]--        -- The definitely-insoluble case is for things like-        --    Int ~ Bool      tycons don't match-        --    a ~ [a]         occurs check-    }--  | CTyEqCan {  -- tv ~ rhs-       -- Invariants:-       --   * See Note [inert_eqs: the inert equalities] in TcSMonad-       --   * (TyEq:OC) tv not in deep tvs(rhs)   (occurs check)-       --   * (TyEq:F) If tv is a TauTv, then rhs has no foralls-       --       (this avoids substituting a forall for the tyvar in other types)-       --   * (TyEq:K) tcTypeKind ty `tcEqKind` tcTypeKind tv; Note [Ct kind invariant]-       --   * (TyEq:AFF) rhs (perhaps under the one cast) is *almost function-free*,-       --       See Note [Almost function-free]-       --   * (TyEq:N) If the equality is representational, rhs has no top-level newtype-       --     See Note [No top-level newtypes on RHS of representational-       --     equalities] in TcCanonical-       --   * (TyEq:TV) If rhs (perhaps under the cast) is also a tv, then it is oriented-       --     to give best chance of-       --     unification happening; eg if rhs is touchable then lhs is too-       --     See TcCanonical Note [Canonical orientation for tyvar/tyvar equality constraints]-       --   * (TyEq:H) The RHS has no blocking coercion holes. See TcCanonical-       --     Note [Equalities with incompatible kinds], wrinkle (2)-      cc_ev     :: CtEvidence, -- See Note [Ct/evidence invariant]-      cc_tyvar  :: TcTyVar,-      cc_rhs    :: TcType,     -- Not necessarily function-free (hence not Xi)-                               -- See invariants above--      cc_eq_rel :: EqRel       -- INVARIANT: cc_eq_rel = ctEvEqRel cc_ev-    }--  | CFunEqCan {  -- F xis ~ fsk-       -- Invariants:-       --   * isTypeFamilyTyCon cc_fun-       --   * tcTypeKind (F xis) = tyVarKind fsk; Note [Ct kind invariant]-       --   * always Nominal role-      cc_ev     :: CtEvidence,  -- See Note [Ct/evidence invariant]-      cc_fun    :: TyCon,       -- A type function--      cc_tyargs :: [Xi],        -- cc_tyargs are function-free (hence Xi)-        -- Either under-saturated or exactly saturated-        --    *never* over-saturated (because if so-        --    we should have decomposed)--      cc_fsk    :: TcTyVar  -- [G]  always a FlatSkolTv-                            -- [W], [WD], or [D] always a FlatMetaTv-        -- See Note [The flattening story] in TcFlatten-    }--  | CNonCanonical {        -- See Note [NonCanonical Semantics] in TcSMonad-      cc_ev  :: CtEvidence-    }--  | CHoleCan {             -- See Note [Hole constraints]-       -- Treated as an "insoluble" constraint-       -- See Note [Insoluble constraints]-      cc_ev   :: CtEvidence,-      cc_occ  :: OccName,   -- The name of this hole-      cc_hole :: HoleSort   -- The sort of this hole (expr, type, ...)-    }--  | CQuantCan QCInst       -- A quantified constraint-      -- NB: I expect to make more of the cases in Ct-      --     look like this, with the payload in an-      --     auxiliary type---------------data QCInst  -- A much simplified version of ClsInst-             -- See Note [Quantified constraints] in TcCanonical-  = QCI { qci_ev   :: CtEvidence -- Always of type forall tvs. context => ty-                                 -- Always Given-        , qci_tvs  :: [TcTyVar]  -- The tvs-        , qci_pred :: TcPredType -- The ty-        , qci_pend_sc :: Bool    -- Same as cc_pend_sc flag in CDictCan-                                 -- Invariant: True => qci_pred is a ClassPred-    }--instance Outputable QCInst where-  ppr (QCI { qci_ev = ev }) = ppr ev----------------- | Used to indicate which sort of hole we have.-data HoleSort = ExprHole-                 -- ^ Either an out-of-scope variable or a "true" hole in an-                 -- expression (TypedHoles)-              | TypeHole-                 -- ^ A hole in a type (PartialTypeSignatures)----------------- | Used to indicate extra information about why a CIrredCan is irreducible-data CtIrredStatus-  = InsolubleCIS   -- this constraint will never be solved-  | BlockedCIS     -- this constraint is blocked on a coercion hole-                   -- The hole will appear in the ctEvPred of the constraint with this status-                   -- See Note [Equalities with incompatible kinds] in TcCanonical-                   -- Wrinkle (4a)-  | OtherCIS--instance Outputable CtIrredStatus where-  ppr InsolubleCIS = text "(insoluble)"-  ppr BlockedCIS   = text "(blocked)"-  ppr OtherCIS     = text "(soluble)"--{- Note [Hole constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~-CHoleCan constraints are used for two kinds of holes,-distinguished by cc_hole:--  * For holes in expressions-    e.g.   f x = g _ x--  * For holes in type signatures-    e.g.   f :: _ -> _-           f x = [x,True]--Note [CIrredCan constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-CIrredCan constraints are used for constraints that are "stuck"-   - we can't solve them (yet)-   - we can't use them to solve other constraints-   - but they may become soluble if we substitute for some-     of the type variables in the constraint--Example 1:  (c Int), where c :: * -> Constraint.  We can't do anything-            with this yet, but if later c := Num, *then* we can solve it--Example 2:  a ~ b, where a :: *, b :: k, where k is a kind variable-            We don't want to use this to substitute 'b' for 'a', in case-            'k' is subsequently unified with (say) *->*, because then-            we'd have ill-kinded types floating about.  Rather we want-            to defer using the equality altogether until 'k' get resolved.--Note [Ct/evidence invariant]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-If  ct :: Ct, then extra fields of 'ct' cache precisely the ctev_pred field-of (cc_ev ct), and is fully rewritten wrt the substitution.   Eg for CDictCan,-   ctev_pred (cc_ev ct) = (cc_class ct) (cc_tyargs ct)-This holds by construction; look at the unique place where CDictCan is-built (in TcCanonical).--In contrast, the type of the evidence *term* (ctev_dest / ctev_evar) in-the evidence may *not* be fully zonked; we are careful not to look at it-during constraint solving. See Note [Evidence field of CtEvidence].--Note [Ct kind invariant]-~~~~~~~~~~~~~~~~~~~~~~~~-CTyEqCan and CFunEqCan both require that the kind of the lhs matches the kind-of the rhs. This is necessary because both constraints are used for substitutions-during solving. If the kinds differed, then the substitution would take a well-kinded-type to an ill-kinded one.--Note [Almost function-free]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-A type is *almost function-free* if it has no type functions (something that-responds True to isTypeFamilyTyCon), except (possibly)- * under a forall, or- * in a coercion (either in a CastTy or a CercionTy)--The RHS of a CTyEqCan must be almost function-free, invariant (TyEq:AFF).-This is for two reasons:--1. There cannot be a top-level function. If there were, the equality should-   really be a CFunEqCan, not a CTyEqCan.--2. Nested functions aren't too bad, on the other hand. However, consider this-   scenario:--     type family F a = r | r -> a--     [D] F ty1 ~ fsk1-     [D] F ty2 ~ fsk2-     [D] fsk1 ~ [G Int]-     [D] fsk2 ~ [G Bool]--     type instance G Int = Char-     type instance G Bool = Char--   If it was the case that fsk1 = fsk2, then we could unifty ty1 and ty2 ---   good! They don't look equal -- but if we aggressively reduce that G Int and-   G Bool they would become equal. The "almost function free" makes sure that-   these redexes are exposed.--   Note that this equality does *not* depend on casts or coercions, and so-   skipping these forms is OK. In addition, the result of a type family cannot-   be a polytype, so skipping foralls is OK, too. We skip foralls because we-   want the output of the flattener to be almost function-free. See Note-   [Flattening under a forall] in TcFlatten.--   As I (Richard E) write this, it is unclear if the scenario pictured above-   can happen -- I would expect the G Int and G Bool to be reduced. But-   perhaps it can arise somehow, and maintaining almost function-free is cheap.--Historical note: CTyEqCans used to require only condition (1) above: that no-type family was at the top of an RHS. But work on #16512 suggested that the-injectivity checks were not complete, and adding the requirement that functions-do not appear even in a nested fashion was easy (it was already true, but-unenforced).--The almost-function-free property is checked by isAlmostFunctionFree in TcType.-The flattener (in TcFlatten) produces types that are almost function-free.---}--mkNonCanonical :: CtEvidence -> Ct-mkNonCanonical ev = CNonCanonical { cc_ev = ev }--mkNonCanonicalCt :: Ct -> Ct-mkNonCanonicalCt ct = CNonCanonical { cc_ev = cc_ev ct }--mkIrredCt :: CtIrredStatus -> CtEvidence -> Ct-mkIrredCt status ev = CIrredCan { cc_ev = ev, cc_status = status }--mkGivens :: CtLoc -> [EvId] -> [Ct]-mkGivens loc ev_ids-  = map mk ev_ids-  where-    mk ev_id = mkNonCanonical (CtGiven { ctev_evar = ev_id-                                       , ctev_pred = evVarPred ev_id-                                       , ctev_loc = loc })--ctEvidence :: Ct -> CtEvidence-ctEvidence (CQuantCan (QCI { qci_ev = ev })) = ev-ctEvidence ct = cc_ev ct--ctLoc :: Ct -> CtLoc-ctLoc = ctEvLoc . ctEvidence--setCtLoc :: Ct -> CtLoc -> Ct-setCtLoc ct loc = ct { cc_ev = (cc_ev ct) { ctev_loc = loc } }--ctOrigin :: Ct -> CtOrigin-ctOrigin = ctLocOrigin . ctLoc--ctPred :: Ct -> PredType--- See Note [Ct/evidence invariant]-ctPred ct = ctEvPred (ctEvidence ct)--ctEvId :: Ct -> EvVar--- The evidence Id for this Ct-ctEvId ct = ctEvEvId (ctEvidence ct)---- | Makes a new equality predicate with the same role as the given--- evidence.-mkTcEqPredLikeEv :: CtEvidence -> TcType -> TcType -> TcType-mkTcEqPredLikeEv ev-  = case predTypeEqRel pred of-      NomEq  -> mkPrimEqPred-      ReprEq -> mkReprPrimEqPred-  where-    pred = ctEvPred ev---- | Get the flavour of the given 'Ct'-ctFlavour :: Ct -> CtFlavour-ctFlavour = ctEvFlavour . ctEvidence---- | Get the equality relation for the given 'Ct'-ctEqRel :: Ct -> EqRel-ctEqRel = ctEvEqRel . ctEvidence--instance Outputable Ct where-  ppr ct = ppr (ctEvidence ct) <+> parens pp_sort-    where-      pp_sort = case ct of-         CTyEqCan {}      -> text "CTyEqCan"-         CFunEqCan {}     -> text "CFunEqCan"-         CNonCanonical {} -> text "CNonCanonical"-         CDictCan { cc_pend_sc = pend_sc }-            | pend_sc   -> text "CDictCan(psc)"-            | otherwise -> text "CDictCan"-         CIrredCan { cc_status = status } -> text "CIrredCan" <> ppr status-         CHoleCan { cc_occ = occ } -> text "CHoleCan:" <+> ppr occ-         CQuantCan (QCI { qci_pend_sc = pend_sc })-            | pend_sc   -> text "CQuantCan(psc)"-            | otherwise -> text "CQuantCan"--{--************************************************************************-*                                                                      *-        Simple functions over evidence variables-*                                                                      *-************************************************************************--}------------------ Getting free tyvars ----------------------------- | Returns free variables of constraints as a non-deterministic set-tyCoVarsOfCt :: Ct -> TcTyCoVarSet-tyCoVarsOfCt = fvVarSet . tyCoFVsOfCt---- | Returns free variables of constraints as a deterministically ordered.--- list. See Note [Deterministic FV] in FV.-tyCoVarsOfCtList :: Ct -> [TcTyCoVar]-tyCoVarsOfCtList = fvVarList . tyCoFVsOfCt---- | Returns free variables of constraints as a composable FV computation.--- See Note [Deterministic FV] in FV.-tyCoFVsOfCt :: Ct -> FV-tyCoFVsOfCt ct = tyCoFVsOfType (ctPred ct)-  -- This must consult only the ctPred, so that it gets *tidied* fvs if the-  -- constraint has been tidied. Tidying a constraint does not tidy the-  -- fields of the Ct, only the predicate in the CtEvidence.---- | Returns free variables of a bag of constraints as a non-deterministic--- set. See Note [Deterministic FV] in FV.-tyCoVarsOfCts :: Cts -> TcTyCoVarSet-tyCoVarsOfCts = fvVarSet . tyCoFVsOfCts---- | Returns free variables of a bag of constraints as a deterministically--- ordered list. See Note [Deterministic FV] in FV.-tyCoVarsOfCtsList :: Cts -> [TcTyCoVar]-tyCoVarsOfCtsList = fvVarList . tyCoFVsOfCts---- | Returns free variables of a bag of constraints as a composable FV--- computation. See Note [Deterministic FV] in FV.-tyCoFVsOfCts :: Cts -> FV-tyCoFVsOfCts = foldr (unionFV . tyCoFVsOfCt) emptyFV---- | Returns free variables of WantedConstraints as a non-deterministic--- set. See Note [Deterministic FV] in FV.-tyCoVarsOfWC :: WantedConstraints -> TyCoVarSet--- Only called on *zonked* things, hence no need to worry about flatten-skolems-tyCoVarsOfWC = fvVarSet . tyCoFVsOfWC---- | Returns free variables of WantedConstraints as a deterministically--- ordered list. See Note [Deterministic FV] in FV.-tyCoVarsOfWCList :: WantedConstraints -> [TyCoVar]--- Only called on *zonked* things, hence no need to worry about flatten-skolems-tyCoVarsOfWCList = fvVarList . tyCoFVsOfWC---- | Returns free variables of WantedConstraints as a composable FV--- computation. See Note [Deterministic FV] in FV.-tyCoFVsOfWC :: WantedConstraints -> FV--- Only called on *zonked* things, hence no need to worry about flatten-skolems-tyCoFVsOfWC (WC { wc_simple = simple, wc_impl = implic })-  = tyCoFVsOfCts simple `unionFV`-    tyCoFVsOfBag tyCoFVsOfImplic implic---- | Returns free variables of Implication as a composable FV computation.--- See Note [Deterministic FV] in FV.-tyCoFVsOfImplic :: Implication -> FV--- Only called on *zonked* things, hence no need to worry about flatten-skolems-tyCoFVsOfImplic (Implic { ic_skols = skols-                        , ic_given = givens-                        , ic_wanted = wanted })-  | isEmptyWC wanted-  = emptyFV-  | otherwise-  = tyCoFVsVarBndrs skols  $-    tyCoFVsVarBndrs givens $-    tyCoFVsOfWC wanted--tyCoFVsOfBag :: (a -> FV) -> Bag a -> FV-tyCoFVsOfBag tvs_of = foldr (unionFV . tvs_of) emptyFV------------------------------dropDerivedWC :: WantedConstraints -> WantedConstraints--- See Note [Dropping derived constraints]-dropDerivedWC wc@(WC { wc_simple = simples })-  = wc { wc_simple = dropDerivedSimples simples }-    -- The wc_impl implications are already (recursively) filtered-----------------------------dropDerivedSimples :: Cts -> Cts--- Drop all Derived constraints, but make [W] back into [WD],--- so that if we re-simplify these constraints we will get all--- the right derived constraints re-generated.  Forgetting this--- step led to #12936-dropDerivedSimples simples = mapMaybeBag dropDerivedCt simples--dropDerivedCt :: Ct -> Maybe Ct-dropDerivedCt ct-  = case ctEvFlavour ev of-      Wanted WOnly -> Just (ct' { cc_ev = ev_wd })-      Wanted _     -> Just ct'-      _ | isDroppableCt ct -> Nothing-        | otherwise        -> Just ct-  where-    ev    = ctEvidence ct-    ev_wd = ev { ctev_nosh = WDeriv }-    ct'   = setPendingScDict ct -- See Note [Resetting cc_pend_sc]--{- Note [Resetting cc_pend_sc]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we discard Derived constraints, in dropDerivedSimples, we must-set the cc_pend_sc flag to True, so that if we re-process this-CDictCan we will re-generate its derived superclasses. Otherwise-we might miss some fundeps.  #13662 showed this up.--See Note [The superclass story] in TcCanonical.--}--isDroppableCt :: Ct -> Bool-isDroppableCt ct-  = isDerived ev && not keep_deriv-    -- Drop only derived constraints, and then only if they-    -- obey Note [Dropping derived constraints]-  where-    ev   = ctEvidence ct-    loc  = ctEvLoc ev-    orig = ctLocOrigin loc--    keep_deriv-      = case ct of-          CHoleCan {}                            -> True-          CIrredCan { cc_status = InsolubleCIS } -> keep_eq True-          _                                      -> keep_eq False--    keep_eq definitely_insoluble-       | isGivenOrigin orig    -- Arising only from givens-       = definitely_insoluble  -- Keep only definitely insoluble-       | otherwise-       = case orig of-           -- See Note [Dropping derived constraints]-           -- For fundeps, drop wanted/wanted interactions-           FunDepOrigin2 {} -> True   -- Top-level/Wanted-           FunDepOrigin1 _ orig1 _ _ orig2 _-             | g1 || g2  -> True  -- Given/Wanted errors: keep all-             | otherwise -> False -- Wanted/Wanted errors: discard-             where-               g1 = isGivenOrigin orig1-               g2 = isGivenOrigin orig2--           _ -> False--arisesFromGivens :: Ct -> Bool-arisesFromGivens ct-  = case ctEvidence ct of-      CtGiven {}                   -> True-      CtWanted {}                  -> False-      CtDerived { ctev_loc = loc } -> isGivenLoc loc--isGivenLoc :: CtLoc -> Bool-isGivenLoc loc = isGivenOrigin (ctLocOrigin loc)--{- Note [Dropping derived constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In general we discard derived constraints at the end of constraint solving;-see dropDerivedWC.  For example-- * Superclasses: if we have an unsolved [W] (Ord a), we don't want to-   complain about an unsolved [D] (Eq a) as well.-- * If we have [W] a ~ Int, [W] a ~ Bool, improvement will generate-   [D] Int ~ Bool, and we don't want to report that because it's-   incomprehensible. That is why we don't rewrite wanteds with wanteds!-- * We might float out some Wanteds from an implication, leaving behind-   their insoluble Deriveds. For example:--   forall a[2]. [W] alpha[1] ~ Int-                [W] alpha[1] ~ Bool-                [D] Int ~ Bool--   The Derived is insoluble, but we very much want to drop it when floating-   out.--But (tiresomely) we do keep *some* Derived constraints:-- * Type holes are derived constraints, because they have no evidence-   and we want to keep them, so we get the error report-- * We keep most derived equalities arising from functional dependencies-      - Given/Given interactions (subset of FunDepOrigin1):-        The definitely-insoluble ones reflect unreachable code.--        Others not-definitely-insoluble ones like [D] a ~ Int do not-        reflect unreachable code; indeed if fundeps generated proofs, it'd-        be a useful equality.  See #14763.   So we discard them.--      - Given/Wanted interacGiven or Wanted interacting with an-        instance declaration (FunDepOrigin2)--      - Given/Wanted interactions (FunDepOrigin1); see #9612--      - But for Wanted/Wanted interactions we do /not/ want to report an-        error (#13506).  Consider [W] C Int Int, [W] C Int Bool, with-        a fundep on class C.  We don't want to report an insoluble Int~Bool;-        c.f. "wanteds do not rewrite wanteds".--To distinguish these cases we use the CtOrigin.--NB: we keep *all* derived insolubles under some circumstances:--  * They are looked at by simplifyInfer, to decide whether to-    generalise.  Example: [W] a ~ Int, [W] a ~ Bool-    We get [D] Int ~ Bool, and indeed the constraints are insoluble,-    and we want simplifyInfer to see that, even though we don't-    ultimately want to generate an (inexplicable) error message from it---************************************************************************-*                                                                      *-                    CtEvidence-         The "flavor" of a canonical constraint-*                                                                      *-************************************************************************--}--isWantedCt :: Ct -> Bool-isWantedCt = isWanted . ctEvidence--isGivenCt :: Ct -> Bool-isGivenCt = isGiven . ctEvidence--isDerivedCt :: Ct -> Bool-isDerivedCt = isDerived . ctEvidence--isCTyEqCan :: Ct -> Bool-isCTyEqCan (CTyEqCan {})  = True-isCTyEqCan _              = False--isCDictCan_Maybe :: Ct -> Maybe Class-isCDictCan_Maybe (CDictCan {cc_class = cls })  = Just cls-isCDictCan_Maybe _              = Nothing--isCFunEqCan_maybe :: Ct -> Maybe (TyCon, [Type])-isCFunEqCan_maybe (CFunEqCan { cc_fun = tc, cc_tyargs = xis }) = Just (tc, xis)-isCFunEqCan_maybe _ = Nothing--isCFunEqCan :: Ct -> Bool-isCFunEqCan (CFunEqCan {}) = True-isCFunEqCan _ = False--isCNonCanonical :: Ct -> Bool-isCNonCanonical (CNonCanonical {}) = True-isCNonCanonical _ = False--isHoleCt:: Ct -> Bool-isHoleCt (CHoleCan {}) = True-isHoleCt _ = False--isOutOfScopeCt :: Ct -> Bool--- A Hole that does not have a leading underscore is--- simply an out-of-scope variable, and we treat that--- a bit differently when it comes to error reporting-isOutOfScopeCt (CHoleCan { cc_occ = occ }) = not (startsWithUnderscore occ)-isOutOfScopeCt _ = False--isExprHoleCt :: Ct -> Bool-isExprHoleCt (CHoleCan { cc_hole = ExprHole }) = True-isExprHoleCt _ = False--isTypeHoleCt :: Ct -> Bool-isTypeHoleCt (CHoleCan { cc_hole = TypeHole }) = True-isTypeHoleCt _ = False---{- Note [Custom type errors in constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--When GHC reports a type-error about an unsolved-constraint, we check-to see if the constraint contains any custom-type errors, and if so-we report them.  Here are some examples of constraints containing type-errors:--TypeError msg           -- The actual constraint is a type error--TypError msg ~ Int      -- Some type was supposed to be Int, but ended up-                        -- being a type error instead--Eq (TypeError msg)      -- A class constraint is stuck due to a type error--F (TypeError msg) ~ a   -- A type function failed to evaluate due to a type err--It is also possible to have constraints where the type error is nested deeper,-for example see #11990, and also:--Eq (F (TypeError msg))  -- Here the type error is nested under a type-function-                        -- call, which failed to evaluate because of it,-                        -- and so the `Eq` constraint was unsolved.-                        -- This may happen when one function calls another-                        -- and the called function produced a custom type error.--}---- | A constraint is considered to be a custom type error, if it contains--- custom type errors anywhere in it.--- See Note [Custom type errors in constraints]-getUserTypeErrorMsg :: Ct -> Maybe Type-getUserTypeErrorMsg ct = findUserTypeError (ctPred ct)-  where-  findUserTypeError t = msum ( userTypeError_maybe t-                             : map findUserTypeError (subTys t)-                             )--  subTys t            = case splitAppTys t of-                          (t,[]) ->-                            case splitTyConApp_maybe t of-                              Nothing     -> []-                              Just (_,ts) -> ts-                          (t,ts) -> t : ts-----isUserTypeErrorCt :: Ct -> Bool-isUserTypeErrorCt ct = case getUserTypeErrorMsg ct of-                         Just _ -> True-                         _      -> False--isPendingScDict :: Ct -> Maybe Ct--- Says whether this is a CDictCan with cc_pend_sc is True,--- AND if so flips the flag-isPendingScDict ct@(CDictCan { cc_pend_sc = True })-                  = Just (ct { cc_pend_sc = False })-isPendingScDict _ = Nothing--isPendingScInst :: QCInst -> Maybe QCInst--- Same as isPendingScDict, but for QCInsts-isPendingScInst qci@(QCI { qci_pend_sc = True })-                  = Just (qci { qci_pend_sc = False })-isPendingScInst _ = Nothing--setPendingScDict :: Ct -> Ct--- Set the cc_pend_sc flag to True-setPendingScDict ct@(CDictCan { cc_pend_sc = False })-                    = ct { cc_pend_sc = True }-setPendingScDict ct = ct--superClassesMightHelp :: WantedConstraints -> Bool--- ^ True if taking superclasses of givens, or of wanteds (to perhaps--- expose more equalities or functional dependencies) might help to--- solve this constraint.  See Note [When superclasses help]-superClassesMightHelp (WC { wc_simple = simples, wc_impl = implics })-  = anyBag might_help_ct simples || anyBag might_help_implic implics-  where-    might_help_implic ic-       | IC_Unsolved <- ic_status ic = superClassesMightHelp (ic_wanted ic)-       | otherwise                   = False--    might_help_ct ct = isWantedCt ct && not (is_ip ct)--    is_ip (CDictCan { cc_class = cls }) = isIPClass cls-    is_ip _                             = False--getPendingWantedScs :: Cts -> ([Ct], Cts)-getPendingWantedScs simples-  = mapAccumBagL get [] simples-  where-    get acc ct | Just ct' <- isPendingScDict ct-               = (ct':acc, ct')-               | otherwise-               = (acc,     ct)--{- Note [When superclasses help]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-First read Note [The superclass story] in TcCanonical.--We expand superclasses and iterate only if there is at unsolved wanted-for which expansion of superclasses (e.g. from given constraints)-might actually help. The function superClassesMightHelp tells if-doing this superclass expansion might help solve this constraint.-Note that--  * We look inside implications; maybe it'll help to expand the Givens-    at level 2 to help solve an unsolved Wanted buried inside an-    implication.  E.g.-        forall a. Ord a => forall b. [W] Eq a--  * Superclasses help only for Wanted constraints.  Derived constraints-    are not really "unsolved" and we certainly don't want them to-    trigger superclass expansion. This was a good part of the loop-    in  #11523--  * Even for Wanted constraints, we say "no" for implicit parameters.-    we have [W] ?x::ty, expanding superclasses won't help:-      - Superclasses can't be implicit parameters-      - If we have a [G] ?x:ty2, then we'll have another unsolved-        [D] ty ~ ty2 (from the functional dependency)-        which will trigger superclass expansion.--    It's a bit of a special case, but it's easy to do.  The runtime cost-    is low because the unsolved set is usually empty anyway (errors-    aside), and the first non-implicit-parameter will terminate the search.--    The special case is worth it (#11480, comment:2) because it-    applies to CallStack constraints, which aren't type errors. If we have-       f :: (C a) => blah-       f x = ...undefined...-    we'll get a CallStack constraint.  If that's the only unsolved-    constraint it'll eventually be solved by defaulting.  So we don't-    want to emit warnings about hitting the simplifier's iteration-    limit.  A CallStack constraint really isn't an unsolved-    constraint; it can always be solved by defaulting.--}--singleCt :: Ct -> Cts-singleCt = unitBag--andCts :: Cts -> Cts -> Cts-andCts = unionBags--listToCts :: [Ct] -> Cts-listToCts = listToBag--ctsElts :: Cts -> [Ct]-ctsElts = bagToList--consCts :: Ct -> Cts -> Cts-consCts = consBag--snocCts :: Cts -> Ct -> Cts-snocCts = snocBag--extendCtsList :: Cts -> [Ct] -> Cts-extendCtsList cts xs | null xs   = cts-                     | otherwise = cts `unionBags` listToBag xs--andManyCts :: [Cts] -> Cts-andManyCts = unionManyBags--emptyCts :: Cts-emptyCts = emptyBag--isEmptyCts :: Cts -> Bool-isEmptyCts = isEmptyBag--pprCts :: Cts -> SDoc-pprCts cts = vcat (map ppr (bagToList cts))--{--************************************************************************-*                                                                      *-                Wanted constraints-     These are forced to be in TcRnTypes because-           TcLclEnv mentions WantedConstraints-           WantedConstraint mentions CtLoc-           CtLoc mentions ErrCtxt-           ErrCtxt mentions TcM-*                                                                      *-v%************************************************************************--}--data WantedConstraints-  = WC { wc_simple :: Cts              -- Unsolved constraints, all wanted-       , wc_impl   :: Bag Implication-    }--emptyWC :: WantedConstraints-emptyWC = WC { wc_simple = emptyBag, wc_impl = emptyBag }--mkSimpleWC :: [CtEvidence] -> WantedConstraints-mkSimpleWC cts-  = WC { wc_simple = listToBag (map mkNonCanonical cts)-       , wc_impl = emptyBag }--mkImplicWC :: Bag Implication -> WantedConstraints-mkImplicWC implic-  = WC { wc_simple = emptyBag, wc_impl = implic }--isEmptyWC :: WantedConstraints -> Bool-isEmptyWC (WC { wc_simple = f, wc_impl = i })-  = isEmptyBag f && isEmptyBag i----- | Checks whether a the given wanted constraints are solved, i.e.--- that there are no simple constraints left and all the implications--- are solved.-isSolvedWC :: WantedConstraints -> Bool-isSolvedWC WC {wc_simple = wc_simple, wc_impl = wc_impl} =-  isEmptyBag wc_simple && allBag (isSolvedStatus . ic_status) wc_impl--andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints-andWC (WC { wc_simple = f1, wc_impl = i1 })-      (WC { wc_simple = f2, wc_impl = i2 })-  = WC { wc_simple = f1 `unionBags` f2-       , wc_impl   = i1 `unionBags` i2 }--unionsWC :: [WantedConstraints] -> WantedConstraints-unionsWC = foldr andWC emptyWC--addSimples :: WantedConstraints -> Bag Ct -> WantedConstraints-addSimples wc cts-  = wc { wc_simple = wc_simple wc `unionBags` cts }-    -- Consider: Put the new constraints at the front, so they get solved first--addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints-addImplics wc implic = wc { wc_impl = wc_impl wc `unionBags` implic }--addInsols :: WantedConstraints -> Bag Ct -> WantedConstraints-addInsols wc cts-  = wc { wc_simple = wc_simple wc `unionBags` cts }--insolublesOnly :: WantedConstraints -> WantedConstraints--- Keep only the definitely-insoluble constraints-insolublesOnly (WC { wc_simple = simples, wc_impl = implics })-  = WC { wc_simple = filterBag insolubleCt simples-       , wc_impl   = mapBag implic_insols_only implics }-  where-    implic_insols_only implic-      = implic { ic_wanted = insolublesOnly (ic_wanted implic) }--isSolvedStatus :: ImplicStatus -> Bool-isSolvedStatus (IC_Solved {}) = True-isSolvedStatus _              = False--isInsolubleStatus :: ImplicStatus -> Bool-isInsolubleStatus IC_Insoluble    = True-isInsolubleStatus IC_BadTelescope = True-isInsolubleStatus _               = False--insolubleImplic :: Implication -> Bool-insolubleImplic ic = isInsolubleStatus (ic_status ic)--insolubleWC :: WantedConstraints -> Bool-insolubleWC (WC { wc_impl = implics, wc_simple = simples })-  =  anyBag insolubleCt simples-  || anyBag insolubleImplic implics--insolubleCt :: Ct -> Bool--- Definitely insoluble, in particular /excluding/ type-hole constraints--- Namely: a) an equality constraint---         b) that is insoluble---         c) and does not arise from a Given-insolubleCt ct-  | isHoleCt ct            = isOutOfScopeCt ct  -- See Note [Insoluble holes]-  | not (insolubleEqCt ct) = False-  | arisesFromGivens ct    = False              -- See Note [Given insolubles]-  | otherwise              = True--insolubleEqCt :: Ct -> Bool--- Returns True of /equality/ constraints--- that are /definitely/ insoluble--- It won't detect some definite errors like---       F a ~ T (F a)--- where F is a type family, which actually has an occurs check------ The function is tuned for application /after/ constraint solving---       i.e. assuming canonicalisation has been done--- E.g.  It'll reply True  for     a ~ [a]---               but False for   [a] ~ a--- and---                   True for  Int ~ F a Int---               but False for  Maybe Int ~ F a Int Int---               (where F is an arity-1 type function)-insolubleEqCt (CIrredCan { cc_status = InsolubleCIS }) = True-insolubleEqCt _                                        = False--instance Outputable WantedConstraints where-  ppr (WC {wc_simple = s, wc_impl = i})-   = text "WC" <+> braces (vcat-        [ ppr_bag (text "wc_simple") s-        , ppr_bag (text "wc_impl") i ])--ppr_bag :: Outputable a => SDoc -> Bag a -> SDoc-ppr_bag doc bag- | isEmptyBag bag = empty- | otherwise      = hang (doc <+> equals)-                       2 (foldr (($$) . ppr) empty bag)--{- Note [Given insolubles]-~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider (#14325, comment:)-    class (a~b) => C a b--    foo :: C a c => a -> c-    foo x = x--    hm3 :: C (f b) b => b -> f b-    hm3 x = foo x--In the RHS of hm3, from the [G] C (f b) b we get the insoluble-[G] f b ~# b.  Then we also get an unsolved [W] C b (f b).-Residual implication looks like-    forall b. C (f b) b => [G] f b ~# b-                           [W] C f (f b)--We do /not/ want to set the implication status to IC_Insoluble,-because that'll suppress reports of [W] C b (f b).  But we-may not report the insoluble [G] f b ~# b either (see Note [Given errors]-in TcErrors), so we may fail to report anything at all!  Yikes.--The same applies to Derived constraints that /arise from/ Givens.-E.g.   f :: (C Int [a]) => blah-where a fundep means we get-       [D] Int ~ [a]-By the same reasoning we must not suppress other errors (#15767)--Bottom line: insolubleWC (called in TcSimplify.setImplicationStatus)-             should ignore givens even if they are insoluble.--Note [Insoluble holes]-~~~~~~~~~~~~~~~~~~~~~~-Hole constraints that ARE NOT treated as truly insoluble:-  a) type holes, arising from PartialTypeSignatures,-  b) "true" expression holes arising from TypedHoles--An "expression hole" or "type hole" constraint isn't really an error-at all; it's a report saying "_ :: Int" here.  But an out-of-scope-variable masquerading as expression holes IS treated as truly-insoluble, so that it trumps other errors during error reporting.-Yuk!--************************************************************************-*                                                                      *-                Implication constraints-*                                                                      *-************************************************************************--}--data Implication-  = Implic {   -- Invariants for a tree of implications:-               -- see TcType Note [TcLevel and untouchable type variables]--      ic_tclvl :: TcLevel,       -- TcLevel of unification variables-                                 -- allocated /inside/ this implication--      ic_skols :: [TcTyVar],     -- Introduced skolems-      ic_info  :: SkolemInfo,    -- See Note [Skolems in an implication]-                                 -- See Note [Shadowing in a constraint]--      ic_telescope :: Maybe SDoc,  -- User-written telescope, if there is one-                                   -- See Note [Checking telescopes]--      ic_given  :: [EvVar],      -- Given evidence variables-                                 --   (order does not matter)-                                 -- See Invariant (GivenInv) in TcType--      ic_no_eqs :: Bool,         -- True  <=> ic_givens have no equalities, for sure-                                 -- False <=> ic_givens might have equalities--      ic_warn_inaccessible :: Bool,-                                 -- True  <=> -Winaccessible-code is enabled-                                 -- at construction. See-                                 -- Note [Avoid -Winaccessible-code when deriving]-                                 -- in TcInstDcls--      ic_env   :: TcLclEnv,-                                 -- Records the TcLClEnv at the time of creation.-                                 ---                                 -- The TcLclEnv gives the source location-                                 -- and error context for the implication, and-                                 -- hence for all the given evidence variables.--      ic_wanted :: WantedConstraints,  -- The wanteds-                                       -- See Invariang (WantedInf) in TcType--      ic_binds  :: EvBindsVar,    -- Points to the place to fill in the-                                  -- abstraction and bindings.--      -- The ic_need fields keep track of which Given evidence-      -- is used by this implication or its children-      -- NB: including stuff used by nested implications that have since-      --     been discarded-      -- See Note [Needed evidence variables]-      ic_need_inner :: VarSet,    -- Includes all used Given evidence-      ic_need_outer :: VarSet,    -- Includes only the free Given evidence-                                  --  i.e. ic_need_inner after deleting-                                  --       (a) givens (b) binders of ic_binds--      ic_status   :: ImplicStatus-    }--implicationPrototype :: Implication-implicationPrototype-   = Implic { -- These fields must be initialised-              ic_tclvl      = panic "newImplic:tclvl"-            , ic_binds      = panic "newImplic:binds"-            , ic_info       = panic "newImplic:info"-            , ic_env        = panic "newImplic:env"-            , ic_warn_inaccessible = panic "newImplic:warn_inaccessible"--              -- The rest have sensible default values-            , ic_skols      = []-            , ic_telescope  = Nothing-            , ic_given      = []-            , ic_wanted     = emptyWC-            , ic_no_eqs     = False-            , ic_status     = IC_Unsolved-            , ic_need_inner = emptyVarSet-            , ic_need_outer = emptyVarSet }--data ImplicStatus-  = IC_Solved     -- All wanteds in the tree are solved, all the way down-       { ics_dead :: [EvVar] }  -- Subset of ic_given that are not needed-         -- See Note [Tracking redundant constraints] in TcSimplify--  | IC_Insoluble  -- At least one insoluble constraint in the tree--  | IC_BadTelescope  -- solved, but the skolems in the telescope are out of-                     -- dependency order--  | IC_Unsolved   -- Neither of the above; might go either way--instance Outputable Implication where-  ppr (Implic { ic_tclvl = tclvl, ic_skols = skols-              , ic_given = given, ic_no_eqs = no_eqs-              , ic_wanted = wanted, ic_status = status-              , ic_binds = binds-              , ic_need_inner = need_in, ic_need_outer = need_out-              , ic_info = info })-   = hang (text "Implic" <+> lbrace)-        2 (sep [ text "TcLevel =" <+> ppr tclvl-               , text "Skolems =" <+> pprTyVars skols-               , text "No-eqs =" <+> ppr no_eqs-               , text "Status =" <+> ppr status-               , hang (text "Given =")  2 (pprEvVars given)-               , hang (text "Wanted =") 2 (ppr wanted)-               , text "Binds =" <+> ppr binds-               , whenPprDebug (text "Needed inner =" <+> ppr need_in)-               , whenPprDebug (text "Needed outer =" <+> ppr need_out)-               , pprSkolInfo info ] <+> rbrace)--instance Outputable ImplicStatus where-  ppr IC_Insoluble    = text "Insoluble"-  ppr IC_BadTelescope = text "Bad telescope"-  ppr IC_Unsolved     = text "Unsolved"-  ppr (IC_Solved { ics_dead = dead })-    = text "Solved" <+> (braces (text "Dead givens =" <+> ppr dead))--{- Note [Checking telescopes]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When kind-checking a /user-written/ type, we might have a "bad telescope"-like this one:-  data SameKind :: forall k. k -> k -> Type-  type Foo :: forall a k (b :: k). SameKind a b -> Type--The kind of 'a' mentions 'k' which is bound after 'a'.  Oops.--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 }--* Having solved {wanted}, before discarding the now-solved implication,-  the constraint solver checks the dependency order of the skolem-  variables (ic_skols).  This is done in setImplicationStatus.--* This check is only necessary if the implication was born from a-  user-written signature.  If, say, it comes from checking a pattern-  match that binds existentials, where the type of the data constructor-  is known to be valid (it in tcConPat), no need for the check.--  So the check is done if and only if ic_telescope is (Just blah).--* If ic_telesope is (Just d), the d::SDoc displays the original,-  user-written type variables.--* Be careful /NOT/ to discard an implication with non-Nothing-  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--Note [Needed evidence variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Th ic_need_evs field holds the free vars of ic_binds, and all the-ic_binds in nested implications.--  * Main purpose: if one of the ic_givens is not mentioned in here, it-    is redundant.--  * solveImplication may drop an implication altogether if it has no-    remaining 'wanteds'. But we still track the free vars of its-    evidence binds, even though it has now disappeared.--Note [Shadowing in a constraint]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We assume NO SHADOWING in a constraint.  Specifically- * The unification variables are all implicitly quantified at top-   level, and are all unique- * The skolem variables bound in ic_skols are all freah when the-   implication is created.-So we can safely substitute. For example, if we have-   forall a.  a~Int => ...(forall b. ...a...)...-we can push the (a~Int) constraint inwards in the "givens" without-worrying that 'b' might clash.--Note [Skolems in an implication]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The skolems in an implication are not there to perform a skolem escape-check.  That happens because all the environment variables are in the-untouchables, and therefore cannot be unified with anything at all,-let alone the skolems.--Instead, ic_skols is used only when considering floating a constraint-outside the implication in TcSimplify.floatEqualities or-TcSimplify.approximateImplications--Note [Insoluble constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Some of the errors that we get during canonicalization are best-reported when all constraints have been simplified as much as-possible. For instance, assume that during simplification the-following constraints arise:-- [Wanted]   F alpha ~  uf1- [Wanted]   beta ~ uf1 beta--When canonicalizing the wanted (beta ~ uf1 beta), if we eagerly fail-we will simply see a message:-    'Can't construct the infinite type  beta ~ uf1 beta'-and the user has no idea what the uf1 variable is.--Instead our plan is that we will NOT fail immediately, but:-    (1) Record the "frozen" error in the ic_insols field-    (2) Isolate the offending constraint from the rest of the inerts-    (3) Keep on simplifying/canonicalizing--At the end, we will hopefully have substituted uf1 := F alpha, and we-will be able to report a more informative error:-    'Can't construct the infinite type beta ~ F alpha beta'--Insoluble constraints *do* include Derived constraints. For example,-a functional dependency might give rise to [D] Int ~ Bool, and we must-report that.  If insolubles did not contain Deriveds, reportErrors would-never see it.---************************************************************************-*                                                                      *-            Pretty printing-*                                                                      *-************************************************************************--}--pprEvVars :: [EvVar] -> SDoc    -- Print with their types-pprEvVars ev_vars = vcat (map pprEvVarWithType ev_vars)--pprEvVarTheta :: [EvVar] -> SDoc-pprEvVarTheta ev_vars = pprTheta (map evVarPred ev_vars)--pprEvVarWithType :: EvVar -> SDoc-pprEvVarWithType v = ppr v <+> dcolon <+> pprType (evVarPred v)----wrapType :: Type -> [TyVar] -> [PredType] -> Type-wrapType ty skols givens = mkSpecForAllTys skols $ mkPhiTy givens ty---{--************************************************************************-*                                                                      *-            CtEvidence-*                                                                      *-************************************************************************--Note [Evidence field of CtEvidence]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-During constraint solving we never look at the type of ctev_evar/ctev_dest;-instead we look at the ctev_pred field.  The evtm/evar field-may be un-zonked.--Note [Bind new Givens immediately]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-For Givens we make new EvVars and bind them immediately. Two main reasons:-  * Gain sharing.  E.g. suppose we start with g :: C a b, where-       class D a => C a b-       class (E a, F a) => D a-    If we generate all g's superclasses as separate EvTerms we might-    get    selD1 (selC1 g) :: E a-           selD2 (selC1 g) :: F a-           selC1 g :: D a-    which we could do more economically as:-           g1 :: D a = selC1 g-           g2 :: E a = selD1 g1-           g3 :: F a = selD2 g1--  * For *coercion* evidence we *must* bind each given:-      class (a~b) => C a b where ....-      f :: C a b => ....-    Then in f's Givens we have g:(C a b) and the superclass sc(g,0):a~b.-    But that superclass selector can't (yet) appear in a coercion-    (see evTermCoercion), so the easy thing is to bind it to an Id.--So a Given has EvVar inside it rather than (as previously) an EvTerm.---}---- | A place for type-checking evidence to go after it is generated.--- Wanted equalities are always HoleDest; other wanteds are always--- EvVarDest.-data TcEvDest-  = EvVarDest EvVar         -- ^ bind this var to the evidence-              -- EvVarDest is always used for non-type-equalities-              -- e.g. class constraints--  | HoleDest  CoercionHole  -- ^ fill in this hole with the evidence-              -- HoleDest is always used for type-equalities-              -- See Note [Coercion holes] in GHC.Core.TyCo.Rep--data CtEvidence-  = CtGiven    -- Truly given, not depending on subgoals-      { ctev_pred :: TcPredType      -- See Note [Ct/evidence invariant]-      , ctev_evar :: EvVar           -- See Note [Evidence field of CtEvidence]-      , ctev_loc  :: CtLoc }---  | CtWanted   -- Wanted goal-      { ctev_pred :: TcPredType     -- See Note [Ct/evidence invariant]-      , ctev_dest :: TcEvDest-      , ctev_nosh :: ShadowInfo     -- See Note [Constraint flavours]-      , ctev_loc  :: CtLoc }--  | CtDerived  -- A goal that we don't really have to solve and can't-               -- immediately rewrite anything other than a derived-               -- (there's no evidence!) but if we do manage to solve-               -- it may help in solving other goals.-      { ctev_pred :: TcPredType-      , ctev_loc  :: CtLoc }--ctEvPred :: CtEvidence -> TcPredType--- The predicate of a flavor-ctEvPred = ctev_pred--ctEvLoc :: CtEvidence -> CtLoc-ctEvLoc = ctev_loc--ctEvOrigin :: CtEvidence -> CtOrigin-ctEvOrigin = ctLocOrigin . ctEvLoc---- | Get the equality relation relevant for a 'CtEvidence'-ctEvEqRel :: CtEvidence -> EqRel-ctEvEqRel = predTypeEqRel . ctEvPred---- | Get the role relevant for a 'CtEvidence'-ctEvRole :: CtEvidence -> Role-ctEvRole = eqRelRole . ctEvEqRel--ctEvTerm :: CtEvidence -> EvTerm-ctEvTerm ev = EvExpr (ctEvExpr ev)--ctEvExpr :: CtEvidence -> EvExpr-ctEvExpr ev@(CtWanted { ctev_dest = HoleDest _ })-            = Coercion $ ctEvCoercion ev-ctEvExpr ev = evId (ctEvEvId ev)--ctEvCoercion :: HasDebugCallStack => CtEvidence -> TcCoercion-ctEvCoercion (CtGiven { ctev_evar = ev_id })-  = mkTcCoVarCo ev_id-ctEvCoercion (CtWanted { ctev_dest = dest })-  | HoleDest hole <- dest-  = -- ctEvCoercion is only called on type equalities-    -- and they always have HoleDests-    mkHoleCo hole-ctEvCoercion ev-  = pprPanic "ctEvCoercion" (ppr ev)--ctEvEvId :: CtEvidence -> EvVar-ctEvEvId (CtWanted { ctev_dest = EvVarDest ev }) = ev-ctEvEvId (CtWanted { ctev_dest = HoleDest h })   = coHoleCoVar h-ctEvEvId (CtGiven  { ctev_evar = ev })           = ev-ctEvEvId ctev@(CtDerived {}) = pprPanic "ctEvId:" (ppr ctev)--instance Outputable TcEvDest where-  ppr (HoleDest h)   = text "hole" <> ppr h-  ppr (EvVarDest ev) = ppr ev--instance Outputable CtEvidence where-  ppr ev = ppr (ctEvFlavour ev)-           <+> pp_ev-           <+> braces (ppr (ctl_depth (ctEvLoc ev))) <> dcolon-                  -- Show the sub-goal depth too-           <+> ppr (ctEvPred ev)-    where-      pp_ev = case ev of-             CtGiven { ctev_evar = v } -> ppr v-             CtWanted {ctev_dest = d } -> ppr d-             CtDerived {}              -> text "_"--isWanted :: CtEvidence -> Bool-isWanted (CtWanted {}) = True-isWanted _ = False--isGiven :: CtEvidence -> Bool-isGiven (CtGiven {})  = True-isGiven _ = False--isDerived :: CtEvidence -> Bool-isDerived (CtDerived {}) = True-isDerived _              = False--{--%************************************************************************-%*                                                                      *-            CtFlavour-%*                                                                      *-%************************************************************************--Note [Constraint flavours]-~~~~~~~~~~~~~~~~~~~~~~~~~~-Constraints come in four flavours:--* [G] Given: we have evidence--* [W] Wanted WOnly: we want evidence--* [D] Derived: any solution must satisfy this constraint, but-      we don't need evidence for it.  Examples include:-        - superclasses of [W] class constraints-        - equalities arising from functional dependencies-          or injectivity--* [WD] Wanted WDeriv: a single constraint that represents-                      both [W] and [D]-  We keep them paired as one both for efficiency, and because-  when we have a finite map  F tys -> CFunEqCan, it's inconvenient-  to have two CFunEqCans in the range--The ctev_nosh field of a Wanted distinguishes between [W] and [WD]--Wanted constraints are born as [WD], but are split into [W] and its-"shadow" [D] in TcSMonad.maybeEmitShadow.--See Note [The improvement story and derived shadows] in TcSMonad--}--data CtFlavour  -- See Note [Constraint flavours]-  = Given-  | Wanted ShadowInfo-  | Derived-  deriving Eq--data ShadowInfo-  = WDeriv   -- [WD] This Wanted constraint has no Derived shadow,-             -- so it behaves like a pair of a Wanted and a Derived-  | WOnly    -- [W] It has a separate derived shadow-             -- See Note [The improvement story and derived shadows] in TcSMonad-  deriving( Eq )--isGivenOrWDeriv :: CtFlavour -> Bool-isGivenOrWDeriv Given           = True-isGivenOrWDeriv (Wanted WDeriv) = True-isGivenOrWDeriv _               = False--instance Outputable CtFlavour where-  ppr Given           = text "[G]"-  ppr (Wanted WDeriv) = text "[WD]"-  ppr (Wanted WOnly)  = text "[W]"-  ppr Derived         = text "[D]"--ctEvFlavour :: CtEvidence -> CtFlavour-ctEvFlavour (CtWanted { ctev_nosh = nosh }) = Wanted nosh-ctEvFlavour (CtGiven {})                    = Given-ctEvFlavour (CtDerived {})                  = Derived---- | Whether or not one 'Ct' can rewrite another is determined by its--- flavour and its equality relation. See also--- Note [Flavours with roles] in TcSMonad-type CtFlavourRole = (CtFlavour, EqRel)---- | Extract the flavour, role, and boxity from a 'CtEvidence'-ctEvFlavourRole :: CtEvidence -> CtFlavourRole-ctEvFlavourRole ev = (ctEvFlavour ev, ctEvEqRel ev)---- | Extract the flavour and role from a 'Ct'-ctFlavourRole :: Ct -> CtFlavourRole--- Uses short-cuts to role for special cases-ctFlavourRole (CDictCan { cc_ev = ev })-  = (ctEvFlavour ev, NomEq)-ctFlavourRole (CTyEqCan { cc_ev = ev, cc_eq_rel = eq_rel })-  = (ctEvFlavour ev, eq_rel)-ctFlavourRole (CFunEqCan { cc_ev = ev })-  = (ctEvFlavour ev, NomEq)-ctFlavourRole (CHoleCan { cc_ev = ev })-  = (ctEvFlavour ev, NomEq)  -- NomEq: CHoleCans can be rewritten by-                             -- by nominal equalities but empahatically-                             -- not by representational equalities-ctFlavourRole ct-  = ctEvFlavourRole (ctEvidence ct)--{- Note [eqCanRewrite]-~~~~~~~~~~~~~~~~~~~~~~-(eqCanRewrite ct1 ct2) holds if the constraint ct1 (a CTyEqCan of form-tv ~ ty) can be used to rewrite ct2.  It must satisfy the properties of-a can-rewrite relation, see Definition [Can-rewrite relation] in-TcSMonad.--With the solver handling Coercible constraints like equality constraints,-the rewrite conditions must take role into account, never allowing-a representational equality to rewrite a nominal one.--Note [Wanteds do not rewrite Wanteds]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We don't allow Wanteds to rewrite Wanteds, because that can give rise-to very confusing type error messages.  A good example is #8450.-Here's another-   f :: a -> Bool-   f x = ( [x,'c'], [x,True] ) `seq` True-Here we get-  [W] a ~ Char-  [W] a ~ Bool-but we do not want to complain about Bool ~ Char!--Note [Deriveds do rewrite Deriveds]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-However we DO allow Deriveds to rewrite Deriveds, because that's how-improvement works; see Note [The improvement story] in TcInteract.--However, for now at least I'm only letting (Derived,NomEq) rewrite-(Derived,NomEq) and not doing anything for ReprEq.  If we have-    eqCanRewriteFR (Derived, NomEq) (Derived, _)  = True-then we lose property R2 of Definition [Can-rewrite relation]-in TcSMonad-  R2.  If f1 >= f, and f2 >= f,-       then either f1 >= f2 or f2 >= f1-Consider f1 = (Given, ReprEq)-         f2 = (Derived, NomEq)-          f = (Derived, ReprEq)--I thought maybe we could never get Derived ReprEq constraints, but-we can; straight from the Wanteds during improvement. And from a Derived-ReprEq we could conceivably get a Derived NomEq improvement (by decomposing-a type constructor with Nomninal role), and hence unify.--}--eqCanRewrite :: EqRel -> EqRel -> Bool-eqCanRewrite NomEq  _      = True-eqCanRewrite ReprEq ReprEq = True-eqCanRewrite ReprEq NomEq  = False--eqCanRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool--- Can fr1 actually rewrite fr2?--- Very important function!--- See Note [eqCanRewrite]--- See Note [Wanteds do not rewrite Wanteds]--- See Note [Deriveds do rewrite Deriveds]-eqCanRewriteFR (Given,         r1)    (_,       r2)    = eqCanRewrite r1 r2-eqCanRewriteFR (Wanted WDeriv, NomEq) (Derived, NomEq) = True-eqCanRewriteFR (Derived,       NomEq) (Derived, NomEq) = True-eqCanRewriteFR _                      _                = False--eqMayRewriteFR :: CtFlavourRole -> CtFlavourRole -> Bool--- Is it /possible/ that fr1 can rewrite fr2?--- This is used when deciding which inerts to kick out,--- at which time a [WD] inert may be split into [W] and [D]-eqMayRewriteFR (Wanted WDeriv, NomEq) (Wanted WDeriv, NomEq) = True-eqMayRewriteFR (Derived,       NomEq) (Wanted WDeriv, NomEq) = True-eqMayRewriteFR fr1 fr2 = eqCanRewriteFR fr1 fr2--------------------{- Note [funEqCanDischarge]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose we have two CFunEqCans with the same LHS:-    (x1:F ts ~ f1) `funEqCanDischarge` (x2:F ts ~ f2)-Can we drop x2 in favour of x1, either unifying-f2 (if it's a flatten meta-var) or adding a new Given-(f1 ~ f2), if x2 is a Given?--Answer: yes if funEqCanDischarge is true.--}--funEqCanDischarge-  :: CtEvidence -> CtEvidence-  -> ( SwapFlag   -- NotSwapped => lhs can discharge rhs-                  -- Swapped    => rhs can discharge lhs-     , Bool)      -- True <=> upgrade non-discharded one-                  --          from [W] to [WD]--- See Note [funEqCanDischarge]-funEqCanDischarge ev1 ev2-  = ASSERT2( ctEvEqRel ev1 == NomEq, ppr ev1 )-    ASSERT2( ctEvEqRel ev2 == NomEq, ppr ev2 )-    -- CFunEqCans are all Nominal, hence asserts-    funEqCanDischargeF (ctEvFlavour ev1) (ctEvFlavour ev2)--funEqCanDischargeF :: CtFlavour -> CtFlavour -> (SwapFlag, Bool)-funEqCanDischargeF Given           _               = (NotSwapped, False)-funEqCanDischargeF _               Given           = (IsSwapped,  False)-funEqCanDischargeF (Wanted WDeriv) _               = (NotSwapped, False)-funEqCanDischargeF _               (Wanted WDeriv) = (IsSwapped,  True)-funEqCanDischargeF (Wanted WOnly)  (Wanted WOnly)  = (NotSwapped, False)-funEqCanDischargeF (Wanted WOnly)  Derived         = (NotSwapped, True)-funEqCanDischargeF Derived         (Wanted WOnly)  = (IsSwapped,  True)-funEqCanDischargeF Derived         Derived         = (NotSwapped, False)---{- Note [eqCanDischarge]-~~~~~~~~~~~~~~~~~~~~~~~~-Suppose we have two identical CTyEqCan equality constraints-(i.e. both LHS and RHS are the same)-      (x1:a~t) `eqCanDischarge` (xs:a~t)-Can we just drop x2 in favour of x1?--Answer: yes if eqCanDischarge is true.--Note that we do /not/ allow Wanted to discharge Derived.-We must keep both.  Why?  Because the Derived may rewrite-other Deriveds in the model whereas the Wanted cannot.--However a Wanted can certainly discharge an identical Wanted.  So-eqCanDischarge does /not/ define a can-rewrite relation in the-sense of Definition [Can-rewrite relation] in TcSMonad.--We /do/ say that a [W] can discharge a [WD].  In evidence terms it-certainly can, and the /caller/ arranges that the otherwise-lost [D]-is spat out as a new Derived.  -}--eqCanDischargeFR :: CtFlavourRole -> CtFlavourRole -> Bool--- See Note [eqCanDischarge]-eqCanDischargeFR (f1,r1) (f2, r2) =  eqCanRewrite r1 r2-                                  && eqCanDischargeF f1 f2--eqCanDischargeF :: CtFlavour -> CtFlavour -> Bool-eqCanDischargeF Given   _                  = True-eqCanDischargeF (Wanted _)      (Wanted _) = True-eqCanDischargeF (Wanted WDeriv) Derived    = True-eqCanDischargeF Derived         Derived    = True-eqCanDischargeF _               _          = False---{--************************************************************************-*                                                                      *-            SubGoalDepth-*                                                                      *-************************************************************************--Note [SubGoalDepth]-~~~~~~~~~~~~~~~~~~~-The 'SubGoalDepth' takes care of stopping the constraint solver from looping.--The counter starts at zero and increases. It includes dictionary constraints,-equality simplification, and type family reduction. (Why combine these? Because-it's actually quite easy to mistake one for another, in sufficiently involved-scenarios, like ConstraintKinds.)--The flag -freduction-depth=n fixes the maximium level.--* The counter includes the depth of type class instance declarations.  Example:-     [W] d{7} : Eq [Int]-  That is d's dictionary-constraint depth is 7.  If we use the instance-     $dfEqList :: Eq a => Eq [a]-  to simplify it, we get-     d{7} = $dfEqList d'{8}-  where d'{8} : Eq Int, and d' has depth 8.--  For civilised (decidable) instance declarations, each increase of-  depth removes a type constructor from the type, so the depth never-  gets big; i.e. is bounded by the structural depth of the type.--* The counter also increments when resolving-equalities involving type functions. Example:-  Assume we have a wanted at depth 7:-    [W] d{7} : F () ~ a-  If there is a type function equation "F () = Int", this would be rewritten to-    [W] d{8} : Int ~ a-  and remembered as having depth 8.--  Again, without UndecidableInstances, this counter is bounded, but without it-  can resolve things ad infinitum. Hence there is a maximum level.--* Lastly, every time an equality is rewritten, the counter increases. Again,-  rewriting an equality constraint normally makes progress, but it's possible-  the "progress" is just the reduction of an infinitely-reducing type family.-  Hence we need to track the rewrites.--When compiling a program requires a greater depth, then GHC recommends turning-off this check entirely by setting -freduction-depth=0. This is because the-exact number that works is highly variable, and is likely to change even between-minor releases. Because this check is solely to prevent infinite compilation-times, it seems safe to disable it when a user has ascertained that their program-doesn't loop at the type level.---}---- | See Note [SubGoalDepth]-newtype SubGoalDepth = SubGoalDepth Int-  deriving (Eq, Ord, Outputable)--initialSubGoalDepth :: SubGoalDepth-initialSubGoalDepth = SubGoalDepth 0--bumpSubGoalDepth :: SubGoalDepth -> SubGoalDepth-bumpSubGoalDepth (SubGoalDepth n) = SubGoalDepth (n + 1)--maxSubGoalDepth :: SubGoalDepth -> SubGoalDepth -> SubGoalDepth-maxSubGoalDepth (SubGoalDepth n) (SubGoalDepth m) = SubGoalDepth (n `max` m)--subGoalDepthExceeded :: DynFlags -> SubGoalDepth -> Bool-subGoalDepthExceeded dflags (SubGoalDepth d)-  = mkIntWithInf d > reductionDepth dflags--{--************************************************************************-*                                                                      *-            CtLoc-*                                                                      *-************************************************************************--The 'CtLoc' gives information about where a constraint came from.-This is important for decent error message reporting because-dictionaries don't appear in the original source code.-type will evolve...---}--data CtLoc = CtLoc { ctl_origin :: CtOrigin-                   , ctl_env    :: TcLclEnv-                   , ctl_t_or_k :: Maybe TypeOrKind  -- OK if we're not sure-                   , ctl_depth  :: !SubGoalDepth }--  -- The TcLclEnv includes particularly-  --    source location:  tcl_loc   :: RealSrcSpan-  --    context:          tcl_ctxt  :: [ErrCtxt]-  --    binder stack:     tcl_bndrs :: TcBinderStack-  --    level:            tcl_tclvl :: TcLevel--mkKindLoc :: TcType -> TcType   -- original *types* being compared-          -> CtLoc -> CtLoc-mkKindLoc s1 s2 loc = setCtLocOrigin (toKindLoc loc)-                        (KindEqOrigin s1 (Just s2) (ctLocOrigin loc)-                                      (ctLocTypeOrKind_maybe loc))---- | Take a CtLoc and moves it to the kind level-toKindLoc :: CtLoc -> CtLoc-toKindLoc loc = loc { ctl_t_or_k = Just KindLevel }--mkGivenLoc :: TcLevel -> SkolemInfo -> TcLclEnv -> CtLoc-mkGivenLoc tclvl skol_info env-  = CtLoc { ctl_origin = GivenOrigin skol_info-          , ctl_env    = setLclEnvTcLevel env tclvl-          , ctl_t_or_k = Nothing    -- this only matters for error msgs-          , ctl_depth  = initialSubGoalDepth }--ctLocEnv :: CtLoc -> TcLclEnv-ctLocEnv = ctl_env--ctLocLevel :: CtLoc -> TcLevel-ctLocLevel loc = getLclEnvTcLevel (ctLocEnv loc)--ctLocDepth :: CtLoc -> SubGoalDepth-ctLocDepth = ctl_depth--ctLocOrigin :: CtLoc -> CtOrigin-ctLocOrigin = ctl_origin--ctLocSpan :: CtLoc -> RealSrcSpan-ctLocSpan (CtLoc { ctl_env = lcl}) = getLclEnvLoc lcl--ctLocTypeOrKind_maybe :: CtLoc -> Maybe TypeOrKind-ctLocTypeOrKind_maybe = ctl_t_or_k--setCtLocSpan :: CtLoc -> RealSrcSpan -> CtLoc-setCtLocSpan ctl@(CtLoc { ctl_env = lcl }) loc = setCtLocEnv ctl (setLclEnvLoc lcl loc)--bumpCtLocDepth :: CtLoc -> CtLoc-bumpCtLocDepth loc@(CtLoc { ctl_depth = d }) = loc { ctl_depth = bumpSubGoalDepth d }--setCtLocOrigin :: CtLoc -> CtOrigin -> CtLoc-setCtLocOrigin ctl orig = ctl { ctl_origin = orig }--updateCtLocOrigin :: CtLoc -> (CtOrigin -> CtOrigin) -> CtLoc-updateCtLocOrigin ctl@(CtLoc { ctl_origin = orig }) upd-  = ctl { ctl_origin = upd orig }--setCtLocEnv :: CtLoc -> TcLclEnv -> CtLoc-setCtLocEnv ctl env = ctl { ctl_env = env }--pprCtLoc :: CtLoc -> SDoc--- "arising from ... at ..."--- Not an instance of Outputable because of the "arising from" prefix-pprCtLoc (CtLoc { ctl_origin = o, ctl_env = lcl})-  = sep [ pprCtOrigin o-        , text "at" <+> ppr (getLclEnvLoc lcl)]
− compiler/typecheck/TcEvidence.hs 
@@ -1,1026 +0,0 @@--- (c) The University of Glasgow 2006--{-# LANGUAGE CPP, DeriveDataTypeable #-}-{-# LANGUAGE LambdaCase #-}--module TcEvidence (--  -- * HsWrapper-  HsWrapper(..),-  (<.>), mkWpTyApps, mkWpEvApps, mkWpEvVarApps, mkWpTyLams,-  mkWpLams, mkWpLet, mkWpCastN, mkWpCastR, collectHsWrapBinders,-  mkWpFun, idHsWrapper, isIdHsWrapper, isErasableHsWrapper,-  pprHsWrapper,--  -- * Evidence bindings-  TcEvBinds(..), EvBindsVar(..),-  EvBindMap(..), emptyEvBindMap, extendEvBinds,-  lookupEvBind, evBindMapBinds, foldEvBindMap, filterEvBindMap,-  isEmptyEvBindMap,-  EvBind(..), emptyTcEvBinds, isEmptyTcEvBinds, mkGivenEvBind, mkWantedEvBind,-  evBindVar, isCoEvBindsVar,--  -- * EvTerm (already a CoreExpr)-  EvTerm(..), EvExpr,-  evId, evCoercion, evCast, evDFunApp,  evDataConApp, evSelector,-  mkEvCast, evVarsOfTerm, mkEvScSelectors, evTypeable, findNeededEvVars,--  evTermCoercion, evTermCoercion_maybe,-  EvCallStack(..),-  EvTypeable(..),--  -- * TcCoercion-  TcCoercion, TcCoercionR, TcCoercionN, TcCoercionP, CoercionHole,-  TcMCoercion,-  Role(..), LeftOrRight(..), pickLR,-  mkTcReflCo, mkTcNomReflCo, mkTcRepReflCo,-  mkTcTyConAppCo, mkTcAppCo, mkTcFunCo,-  mkTcAxInstCo, mkTcUnbranchedAxInstCo, mkTcForAllCo, mkTcForAllCos,-  mkTcSymCo, mkTcTransCo, mkTcNthCo, mkTcLRCo, mkTcSubCo, maybeTcSubCo,-  tcDowngradeRole,-  mkTcAxiomRuleCo, mkTcGReflRightCo, mkTcGReflLeftCo, mkTcPhantomCo,-  mkTcCoherenceLeftCo,-  mkTcCoherenceRightCo,-  mkTcKindCo,-  tcCoercionKind, coVarsOfTcCo,-  mkTcCoVarCo,-  isTcReflCo, isTcReflexiveCo, isTcGReflMCo, tcCoToMCo,-  tcCoercionRole,-  unwrapIP, wrapIP,--  -- * QuoteWrapper-  QuoteWrapper(..), applyQuoteWrapper, quoteWrapperTyVarTy-  ) where-#include "HsVersions.h"--import GhcPrelude--import GHC.Types.Var-import GHC.Core.Coercion.Axiom-import GHC.Core.Coercion-import GHC.Core.Ppr ()   -- Instance OutputableBndr TyVar-import TcType-import GHC.Core.Type-import GHC.Core.TyCon-import GHC.Core.DataCon( DataCon, dataConWrapId )-import GHC.Core.Class( Class )-import PrelNames-import GHC.Types.Var.Env-import GHC.Types.Var.Set-import GHC.Core.Predicate-import GHC.Types.Name-import Pair--import GHC.Core-import GHC.Core.Class ( classSCSelId )-import GHC.Core.FVs   ( exprSomeFreeVars )--import Util-import Bag-import qualified Data.Data as Data-import Outputable-import GHC.Types.SrcLoc-import Data.IORef( IORef )-import GHC.Types.Unique.Set--{--Note [TcCoercions]-~~~~~~~~~~~~~~~~~~-| TcCoercions are a hack used by the typechecker. Normally,-Coercions have free variables of type (a ~# b): we call these-CoVars. However, the type checker passes around equality evidence-(boxed up) at type (a ~ b).--An TcCoercion is simply a Coercion whose free variables have may be either-boxed or unboxed. After we are done with typechecking the desugarer finds the-boxed free variables, unboxes them, and creates a resulting real Coercion with-kosher free variables.---}--type TcCoercion  = Coercion-type TcCoercionN = CoercionN    -- A Nominal          coercion ~N-type TcCoercionR = CoercionR    -- A Representational coercion ~R-type TcCoercionP = CoercionP    -- a phantom coercion-type TcMCoercion = MCoercion--mkTcReflCo             :: Role -> TcType -> TcCoercion-mkTcSymCo              :: TcCoercion -> TcCoercion-mkTcTransCo            :: TcCoercion -> TcCoercion -> TcCoercion-mkTcNomReflCo          :: TcType -> TcCoercionN-mkTcRepReflCo          :: TcType -> TcCoercionR-mkTcTyConAppCo         :: Role -> TyCon -> [TcCoercion] -> TcCoercion-mkTcAppCo              :: TcCoercion -> TcCoercionN -> TcCoercion-mkTcFunCo              :: Role -> TcCoercion -> TcCoercion -> TcCoercion-mkTcAxInstCo           :: Role -> CoAxiom br -> BranchIndex-                       -> [TcType] -> [TcCoercion] -> TcCoercion-mkTcUnbranchedAxInstCo :: CoAxiom Unbranched -> [TcType]-                       -> [TcCoercion] -> TcCoercionR-mkTcForAllCo           :: TyVar -> TcCoercionN -> TcCoercion -> TcCoercion-mkTcForAllCos          :: [(TyVar, TcCoercionN)] -> TcCoercion -> TcCoercion-mkTcNthCo              :: Role -> Int -> TcCoercion -> TcCoercion-mkTcLRCo               :: LeftOrRight -> TcCoercion -> TcCoercion-mkTcSubCo              :: TcCoercionN -> TcCoercionR-tcDowngradeRole        :: Role -> Role -> TcCoercion -> TcCoercion-mkTcAxiomRuleCo        :: CoAxiomRule -> [TcCoercion] -> TcCoercionR-mkTcGReflRightCo       :: Role -> TcType -> TcCoercionN -> TcCoercion-mkTcGReflLeftCo        :: Role -> TcType -> TcCoercionN -> TcCoercion-mkTcCoherenceLeftCo    :: Role -> TcType -> TcCoercionN-                       -> TcCoercion -> TcCoercion-mkTcCoherenceRightCo   :: Role -> TcType -> TcCoercionN-                       -> TcCoercion -> TcCoercion-mkTcPhantomCo          :: TcCoercionN -> TcType -> TcType -> TcCoercionP-mkTcKindCo             :: TcCoercion -> TcCoercionN-mkTcCoVarCo            :: CoVar -> TcCoercion--tcCoercionKind         :: TcCoercion -> Pair TcType-tcCoercionRole         :: TcCoercion -> Role-coVarsOfTcCo           :: TcCoercion -> TcTyCoVarSet-isTcReflCo             :: TcCoercion -> Bool-isTcGReflMCo           :: TcMCoercion -> Bool---- | This version does a slow check, calculating the related types and seeing--- if they are equal.-isTcReflexiveCo        :: TcCoercion -> Bool--mkTcReflCo             = mkReflCo-mkTcSymCo              = mkSymCo-mkTcTransCo            = mkTransCo-mkTcNomReflCo          = mkNomReflCo-mkTcRepReflCo          = mkRepReflCo-mkTcTyConAppCo         = mkTyConAppCo-mkTcAppCo              = mkAppCo-mkTcFunCo              = mkFunCo-mkTcAxInstCo           = mkAxInstCo-mkTcUnbranchedAxInstCo = mkUnbranchedAxInstCo Representational-mkTcForAllCo           = mkForAllCo-mkTcForAllCos          = mkForAllCos-mkTcNthCo              = mkNthCo-mkTcLRCo               = mkLRCo-mkTcSubCo              = mkSubCo-tcDowngradeRole        = downgradeRole-mkTcAxiomRuleCo        = mkAxiomRuleCo-mkTcGReflRightCo       = mkGReflRightCo-mkTcGReflLeftCo        = mkGReflLeftCo-mkTcCoherenceLeftCo    = mkCoherenceLeftCo-mkTcCoherenceRightCo   = mkCoherenceRightCo-mkTcPhantomCo          = mkPhantomCo-mkTcKindCo             = mkKindCo-mkTcCoVarCo            = mkCoVarCo--tcCoercionKind         = coercionKind-tcCoercionRole         = coercionRole-coVarsOfTcCo           = coVarsOfCo-isTcReflCo             = isReflCo-isTcGReflMCo           = isGReflMCo-isTcReflexiveCo        = isReflexiveCo--tcCoToMCo :: TcCoercion -> TcMCoercion-tcCoToMCo = coToMCo---- | If the EqRel is ReprEq, makes a SubCo; otherwise, does nothing.--- Note that the input coercion should always be nominal.-maybeTcSubCo :: EqRel -> TcCoercion -> TcCoercion-maybeTcSubCo NomEq  = id-maybeTcSubCo ReprEq = mkTcSubCo---{--%************************************************************************-%*                                                                      *-                  HsWrapper-*                                                                      *-************************************************************************--}--data HsWrapper-  = WpHole                      -- The identity coercion--  | WpCompose HsWrapper HsWrapper-       -- (wrap1 `WpCompose` wrap2)[e] = wrap1[ wrap2[ e ]]-       ---       -- Hence  (\a. []) `WpCompose` (\b. []) = (\a b. [])-       -- But    ([] a)   `WpCompose` ([] b)   = ([] b a)--  | WpFun HsWrapper HsWrapper TcType SDoc-       -- (WpFun wrap1 wrap2 t1)[e] = \(x:t1). wrap2[ e wrap1[x] ]-       -- So note that if  wrap1 :: exp_arg <= act_arg-       --                  wrap2 :: act_res <= exp_res-       --           then   WpFun wrap1 wrap2 : (act_arg -> arg_res) <= (exp_arg -> exp_res)-       -- This isn't the same as for mkFunCo, but it has to be this way-       -- because we can't use 'sym' to flip around these HsWrappers-       -- 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 GHC.HsToCore.Monad--  | WpCast TcCoercionR        -- A cast:  [] `cast` co-                              -- Guaranteed not the identity coercion-                              -- At role Representational--        -- Evidence abstraction and application-        -- (both dictionaries and coercions)-  | WpEvLam EvVar               -- \d. []       the 'd' is an evidence variable-  | WpEvApp EvTerm              -- [] d         the 'd' is evidence for a constraint-        -- Kind and Type abstraction and application-  | WpTyLam TyVar       -- \a. []  the 'a' is a type/kind variable (not coercion var)-  | WpTyApp KindOrType  -- [] t    the 't' is a type (not coercion)---  | WpLet TcEvBinds             -- Non-empty (or possibly non-empty) evidence bindings,-                                -- so that the identity coercion is always exactly WpHole---- Cannot derive Data instance because SDoc is not Data (it stores a function).--- So we do it manually:-instance Data.Data HsWrapper where-  gfoldl _ z WpHole             = z WpHole-  gfoldl k z (WpCompose a1 a2)  = z WpCompose `k` a1 `k` a2-  gfoldl k z (WpFun a1 a2 a3 _) = z wpFunEmpty `k` a1 `k` a2 `k` a3-  gfoldl k z (WpCast a1)        = z WpCast `k` a1-  gfoldl k z (WpEvLam a1)       = z WpEvLam `k` a1-  gfoldl k z (WpEvApp a1)       = z WpEvApp `k` a1-  gfoldl k z (WpTyLam a1)       = z WpTyLam `k` a1-  gfoldl k z (WpTyApp a1)       = z WpTyApp `k` a1-  gfoldl k z (WpLet a1)         = z WpLet `k` a1--  gunfold k z c = case Data.constrIndex c of-                    1 -> z WpHole-                    2 -> k (k (z WpCompose))-                    3 -> k (k (k (z wpFunEmpty)))-                    4 -> k (z WpCast)-                    5 -> k (z WpEvLam)-                    6 -> k (z WpEvApp)-                    7 -> k (z WpTyLam)-                    8 -> k (z WpTyApp)-                    _ -> k (z WpLet)--  toConstr WpHole          = wpHole_constr-  toConstr (WpCompose _ _) = wpCompose_constr-  toConstr (WpFun _ _ _ _) = wpFun_constr-  toConstr (WpCast _)      = wpCast_constr-  toConstr (WpEvLam _)     = wpEvLam_constr-  toConstr (WpEvApp _)     = wpEvApp_constr-  toConstr (WpTyLam _)     = wpTyLam_constr-  toConstr (WpTyApp _)     = wpTyApp_constr-  toConstr (WpLet _)       = wpLet_constr--  dataTypeOf _ = hsWrapper_dataType--hsWrapper_dataType :: Data.DataType-hsWrapper_dataType-  = Data.mkDataType "HsWrapper"-      [ wpHole_constr, wpCompose_constr, wpFun_constr, wpCast_constr-      , wpEvLam_constr, wpEvApp_constr, wpTyLam_constr, wpTyApp_constr-      , wpLet_constr]--wpHole_constr, wpCompose_constr, wpFun_constr, wpCast_constr, wpEvLam_constr,-  wpEvApp_constr, wpTyLam_constr, wpTyApp_constr, wpLet_constr :: Data.Constr-wpHole_constr    = mkHsWrapperConstr "WpHole"-wpCompose_constr = mkHsWrapperConstr "WpCompose"-wpFun_constr     = mkHsWrapperConstr "WpFun"-wpCast_constr    = mkHsWrapperConstr "WpCast"-wpEvLam_constr   = mkHsWrapperConstr "WpEvLam"-wpEvApp_constr   = mkHsWrapperConstr "WpEvApp"-wpTyLam_constr   = mkHsWrapperConstr "WpTyLam"-wpTyApp_constr   = mkHsWrapperConstr "WpTyApp"-wpLet_constr     = mkHsWrapperConstr "WpLet"--mkHsWrapperConstr :: String -> Data.Constr-mkHsWrapperConstr name = Data.mkConstr hsWrapper_dataType name [] Data.Prefix--wpFunEmpty :: HsWrapper -> HsWrapper -> TcType -> HsWrapper-wpFunEmpty c1 c2 t1 = WpFun c1 c2 t1 empty--(<.>) :: HsWrapper -> HsWrapper -> HsWrapper-WpHole <.> c = c-c <.> WpHole = c-c1 <.> c2    = c1 `WpCompose` c2--mkWpFun :: HsWrapper -> HsWrapper-        -> TcType    -- the "from" type of the first wrapper-        -> TcType    -- either type of the second wrapper (used only when the-                     -- second wrapper is the identity)-        -> SDoc      -- what caused you to want a WpFun? Something like "When converting ..."-        -> HsWrapper-mkWpFun WpHole       WpHole       _  _  _ = WpHole-mkWpFun WpHole       (WpCast co2) t1 _  _ = WpCast (mkTcFunCo Representational (mkTcRepReflCo t1) co2)-mkWpFun (WpCast co1) WpHole       _  t2 _ = WpCast (mkTcFunCo Representational (mkTcSymCo co1) (mkTcRepReflCo t2))-mkWpFun (WpCast co1) (WpCast co2) _  _  _ = WpCast (mkTcFunCo Representational (mkTcSymCo co1) co2)-mkWpFun co1          co2          t1 _  d = WpFun co1 co2 t1 d--mkWpCastR :: TcCoercionR -> HsWrapper-mkWpCastR co-  | isTcReflCo co = WpHole-  | otherwise     = ASSERT2(tcCoercionRole co == Representational, ppr co)-                    WpCast co--mkWpCastN :: TcCoercionN -> HsWrapper-mkWpCastN co-  | isTcReflCo co = WpHole-  | otherwise     = ASSERT2(tcCoercionRole co == Nominal, ppr co)-                    WpCast (mkTcSubCo co)-    -- The mkTcSubCo converts Nominal to Representational--mkWpTyApps :: [Type] -> HsWrapper-mkWpTyApps tys = mk_co_app_fn WpTyApp tys--mkWpEvApps :: [EvTerm] -> HsWrapper-mkWpEvApps args = mk_co_app_fn WpEvApp args--mkWpEvVarApps :: [EvVar] -> HsWrapper-mkWpEvVarApps vs = mk_co_app_fn WpEvApp (map (EvExpr . evId) vs)--mkWpTyLams :: [TyVar] -> HsWrapper-mkWpTyLams ids = mk_co_lam_fn WpTyLam ids--mkWpLams :: [Var] -> HsWrapper-mkWpLams ids = mk_co_lam_fn WpEvLam ids--mkWpLet :: TcEvBinds -> HsWrapper--- This no-op is a quite a common case-mkWpLet (EvBinds b) | isEmptyBag b = WpHole-mkWpLet ev_binds                   = WpLet ev_binds--mk_co_lam_fn :: (a -> HsWrapper) -> [a] -> HsWrapper-mk_co_lam_fn f as = foldr (\x wrap -> f x <.> wrap) WpHole as--mk_co_app_fn :: (a -> HsWrapper) -> [a] -> HsWrapper--- For applications, the *first* argument must--- come *last* in the composition sequence-mk_co_app_fn f as = foldr (\x wrap -> wrap <.> f x) WpHole as--idHsWrapper :: HsWrapper-idHsWrapper = WpHole--isIdHsWrapper :: HsWrapper -> Bool-isIdHsWrapper WpHole = True-isIdHsWrapper _      = False---- | Is the wrapper erasable, i.e., will not affect runtime semantics?-isErasableHsWrapper :: HsWrapper -> Bool-isErasableHsWrapper = go-  where-    go WpHole                  = True-    go (WpCompose wrap1 wrap2) = go wrap1 && go wrap2-    go WpFun{}                 = False-    go WpCast{}                = True-    go WpEvLam{}               = False -- case in point-    go WpEvApp{}               = False-    go WpTyLam{}               = True-    go WpTyApp{}               = True-    go WpLet{}                 = False--collectHsWrapBinders :: HsWrapper -> ([Var], HsWrapper)--- Collect the outer lambda binders of a HsWrapper,--- stopping as soon as you get to a non-lambda binder-collectHsWrapBinders wrap = go wrap []-  where-    -- go w ws = collectHsWrapBinders (w <.> w1 <.> ... <.> wn)-    go :: HsWrapper -> [HsWrapper] -> ([Var], HsWrapper)-    go (WpEvLam v)       wraps = add_lam v (gos wraps)-    go (WpTyLam v)       wraps = add_lam v (gos wraps)-    go (WpCompose w1 w2) wraps = go w1 (w2:wraps)-    go wrap              wraps = ([], foldl' (<.>) wrap wraps)--    gos []     = ([], WpHole)-    gos (w:ws) = go w ws--    add_lam v (vs,w) = (v:vs, w)--{--************************************************************************-*                                                                      *-                  Evidence bindings-*                                                                      *-************************************************************************--}--data TcEvBinds-  = TcEvBinds           -- Mutable evidence bindings-       EvBindsVar       -- Mutable because they are updated "later"-                        --    when an implication constraint is solved--  | EvBinds             -- Immutable after zonking-       (Bag EvBind)--data EvBindsVar-  = EvBindsVar {-      ebv_uniq :: Unique,-         -- The Unique is for debug printing only--      ebv_binds :: IORef EvBindMap,-      -- The main payload: the value-level evidence bindings-      --     (dictionaries etc)-      -- Some Given, some Wanted--      ebv_tcvs :: IORef CoVarSet-      -- The free Given coercion vars needed by Wanted coercions that-      -- are solved by filling in their HoleDest in-place. Since they-      -- don't appear in ebv_binds, we keep track of their free-      -- variables so that we can report unused given constraints-      -- See Note [Tracking redundant constraints] in TcSimplify-    }--  | CoEvBindsVar {  -- See Note [Coercion evidence only]--      -- See above for comments on ebv_uniq, ebv_tcvs-      ebv_uniq :: Unique,-      ebv_tcvs :: IORef CoVarSet-    }--instance Data.Data TcEvBinds where-  -- Placeholder; we can't travers into TcEvBinds-  toConstr _   = abstractConstr "TcEvBinds"-  gunfold _ _  = error "gunfold"-  dataTypeOf _ = Data.mkNoRepType "TcEvBinds"--{- Note [Coercion evidence only]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Class constraints etc give rise to /term/ bindings for evidence, and-we have nowhere to put term bindings in /types/.  So in some places we-use CoEvBindsVar (see newCoTcEvBinds) to signal that no term-level-evidence bindings are allowed.  Notebly ():--  - Places in types where we are solving kind constraints (all of which-    are equalities); see solveEqualities, solveLocalEqualities--  - When unifying forall-types--}--isCoEvBindsVar :: EvBindsVar -> Bool-isCoEvBindsVar (CoEvBindsVar {}) = True-isCoEvBindsVar (EvBindsVar {})   = False--------------------newtype EvBindMap-  = EvBindMap {-       ev_bind_varenv :: DVarEnv EvBind-    }       -- Map from evidence variables to evidence terms-            -- We use @DVarEnv@ here to get deterministic ordering when we-            -- turn it into a Bag.-            -- If we don't do that, when we generate let bindings for-            -- dictionaries in dsTcEvBinds they will be generated in random-            -- order.-            ---            -- For example:-            ---            -- let $dEq = GHC.Classes.$fEqInt in-            -- let $$dNum = GHC.Num.$fNumInt in ...-            ---            -- vs-            ---            -- let $dNum = GHC.Num.$fNumInt in-            -- let $dEq = GHC.Classes.$fEqInt in ...-            ---            -- See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why-            -- @UniqFM@ can lead to nondeterministic order.--emptyEvBindMap :: EvBindMap-emptyEvBindMap = EvBindMap { ev_bind_varenv = emptyDVarEnv }--extendEvBinds :: EvBindMap -> EvBind -> EvBindMap-extendEvBinds bs ev_bind-  = EvBindMap { ev_bind_varenv = extendDVarEnv (ev_bind_varenv bs)-                                               (eb_lhs ev_bind)-                                               ev_bind }--isEmptyEvBindMap :: EvBindMap -> Bool-isEmptyEvBindMap (EvBindMap m) = isEmptyDVarEnv m--lookupEvBind :: EvBindMap -> EvVar -> Maybe EvBind-lookupEvBind bs = lookupDVarEnv (ev_bind_varenv bs)--evBindMapBinds :: EvBindMap -> Bag EvBind-evBindMapBinds = foldEvBindMap consBag emptyBag--foldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a-foldEvBindMap k z bs = foldDVarEnv k z (ev_bind_varenv bs)--filterEvBindMap :: (EvBind -> Bool) -> EvBindMap -> EvBindMap-filterEvBindMap k (EvBindMap { ev_bind_varenv = env })-  = EvBindMap { ev_bind_varenv = filterDVarEnv k env }--instance Outputable EvBindMap where-  ppr (EvBindMap m) = ppr m---------------------- All evidence is bound by EvBinds; no side effects-data EvBind-  = EvBind { eb_lhs      :: EvVar-           , eb_rhs      :: EvTerm-           , eb_is_given :: Bool  -- True <=> given-                 -- See Note [Tracking redundant constraints] in TcSimplify-    }--evBindVar :: EvBind -> EvVar-evBindVar = eb_lhs--mkWantedEvBind :: EvVar -> EvTerm -> EvBind-mkWantedEvBind ev tm = EvBind { eb_is_given = False, eb_lhs = ev, eb_rhs = tm }---- EvTypeable are never given, so we can work with EvExpr here instead of EvTerm-mkGivenEvBind :: EvVar -> EvTerm -> EvBind-mkGivenEvBind ev tm = EvBind { eb_is_given = True, eb_lhs = ev, eb_rhs = tm }----- An EvTerm is, conceptually, a CoreExpr that implements the constraint.--- Unfortunately, we cannot just do---   type EvTerm  = CoreExpr--- Because of staging problems issues around EvTypeable-data EvTerm-  = EvExpr EvExpr--  | EvTypeable Type EvTypeable   -- Dictionary for (Typeable ty)--  | EvFun     -- /\as \ds. let binds in v-      { et_tvs   :: [TyVar]-      , et_given :: [EvVar]-      , et_binds :: TcEvBinds -- This field is why we need an EvFun-                              -- constructor, and can't just use EvExpr-      , et_body  :: EvVar }--  deriving Data.Data--type EvExpr = CoreExpr---- An EvTerm is (usually) constructed by any of the constructors here--- and those more complicates ones who were moved to module TcEvTerm---- | Any sort of evidence Id, including coercions-evId ::  EvId -> EvExpr-evId = Var---- coercion bindings--- See Note [Coercion evidence terms]-evCoercion :: TcCoercion -> EvTerm-evCoercion co = EvExpr (Coercion co)---- | d |> co-evCast :: EvExpr -> TcCoercion -> EvTerm-evCast et tc | isReflCo tc = EvExpr et-             | otherwise   = EvExpr (Cast et tc)---- Dictionary instance application-evDFunApp :: DFunId -> [Type] -> [EvExpr] -> EvTerm-evDFunApp df tys ets = EvExpr $ Var df `mkTyApps` tys `mkApps` ets--evDataConApp :: DataCon -> [Type] -> [EvExpr] -> EvTerm-evDataConApp dc tys ets = evDFunApp (dataConWrapId dc) tys ets---- Selector id plus the types at which it--- should be instantiated, used for HasField--- dictionaries; see Note [HasField instances]--- in TcInterface-evSelector :: Id -> [Type] -> [EvExpr] -> EvExpr-evSelector sel_id tys tms = Var sel_id `mkTyApps` tys `mkApps` tms---- Dictionary for (Typeable ty)-evTypeable :: Type -> EvTypeable -> EvTerm-evTypeable = EvTypeable---- | Instructions on how to make a 'Typeable' dictionary.--- See Note [Typeable evidence terms]-data EvTypeable-  = EvTypeableTyCon TyCon [EvTerm]-    -- ^ Dictionary for @Typeable T@ where @T@ is a type constructor with all of-    -- its kind variables saturated. The @[EvTerm]@ is @Typeable@ evidence for-    -- the applied kinds..--  | EvTypeableTyApp EvTerm EvTerm-    -- ^ Dictionary for @Typeable (s t)@,-    -- given a dictionaries for @s@ and @t@.--  | EvTypeableTrFun EvTerm EvTerm-    -- ^ Dictionary for @Typeable (s -> t)@,-    -- given a dictionaries for @s@ and @t@.--  | EvTypeableTyLit EvTerm-    -- ^ Dictionary for a type literal,-    -- e.g. @Typeable "foo"@ or @Typeable 3@-    -- The 'EvTerm' is evidence of, e.g., @KnownNat 3@-    -- (see #10348)-  deriving Data.Data---- | Evidence for @CallStack@ implicit parameters.-data EvCallStack-  -- See Note [Overview of implicit CallStacks]-  = EvCsEmpty-  | EvCsPushCall Name RealSrcSpan EvExpr-    -- ^ @EvCsPushCall name loc stk@ represents a call to @name@, occurring at-    -- @loc@, in a calling context @stk@.-  deriving Data.Data--{--Note [Typeable evidence terms]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The EvTypeable data type looks isomorphic to Type, but the EvTerms-inside can be EvIds.  Eg-    f :: forall a. Typeable a => a -> TypeRep-    f x = typeRep (undefined :: Proxy [a])-Here for the (Typeable [a]) dictionary passed to typeRep we make-evidence-    dl :: Typeable [a] = EvTypeable [a]-                            (EvTypeableTyApp (EvTypeableTyCon []) (EvId d))-where-    d :: Typable a-is the lambda-bound dictionary passed into f.--Note [Coercion evidence terms]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A "coercion evidence term" takes one of these forms-   co_tm ::= EvId v           where v :: t1 ~# t2-           | EvCoercion co-           | EvCast co_tm co--We do quite often need to get a TcCoercion from an EvTerm; see-'evTermCoercion'.--INVARIANT: The evidence for any constraint with type (t1 ~# t2) is-a coercion evidence term.  Consider for example-    [G] d :: F Int a-If we have-    ax7 a :: F Int a ~ (a ~ Bool)-then we do NOT generate the constraint-    [G] (d |> ax7 a) :: a ~ Bool-because that does not satisfy the invariant (d is not a coercion variable).-Instead we make a binding-    g1 :: a~Bool = g |> ax7 a-and the constraint-    [G] g1 :: a~Bool-See #7238 and Note [Bind new Givens immediately] in Constraint--Note [EvBinds/EvTerm]-~~~~~~~~~~~~~~~~~~~~~-How evidence is created and updated. Bindings for dictionaries,-and coercions and implicit parameters are carried around in TcEvBinds-which during constraint generation and simplification is always of the-form (TcEvBinds ref). After constraint simplification is finished it-will be transformed to t an (EvBinds ev_bag).--Evidence for coercions *SHOULD* be filled in using the TcEvBinds-However, all EvVars that correspond to *wanted* coercion terms in-an EvBind must be mutable variables so that they can be readily-inlined (by zonking) after constraint simplification is finished.--Conclusion: a new wanted coercion variable should be made mutable.-[Notice though that evidence variables that bind coercion terms- from super classes will be "given" and hence rigid]---Note [Overview of implicit CallStacks]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-(See https://gitlab.haskell.org/ghc/ghc/wikis/explicit-call-stack/implicit-locations)--The goal of CallStack evidence terms is to reify locations-in the program source as runtime values, without any support-from the RTS. We accomplish this by assigning a special meaning-to constraints of type GHC.Stack.Types.HasCallStack, an alias--  type HasCallStack = (?callStack :: CallStack)--Implicit parameters of type GHC.Stack.Types.CallStack (the name is not-important) are solved in three steps:--1. Occurrences of CallStack IPs are solved directly from the given IP,-   just like a regular IP. For example, the occurrence of `?stk` in--     error :: (?stk :: CallStack) => String -> a-     error s = raise (ErrorCall (s ++ prettyCallStack ?stk))--   will be solved for the `?stk` in `error`s context as before.--2. In a function call, instead of simply passing the given IP, we first-   append the current call-site to it. For example, consider a-   call to the callstack-aware `error` above.--     undefined :: (?stk :: CallStack) => a-     undefined = error "undefined!"--   Here we want to take the given `?stk` and append the current-   call-site, before passing it to `error`. In essence, we want to-   rewrite `error "undefined!"` to--     let ?stk = pushCallStack <error's location> ?stk-     in error "undefined!"--   We achieve this effect by emitting a NEW wanted--     [W] d :: IP "stk" CallStack--   from which we build the evidence term--     EvCsPushCall "error" <error's location> (EvId d)--   that we use to solve the call to `error`. The new wanted `d` will-   then be solved per rule (1), ie as a regular IP.--   (see TcInteract.interactDict)--3. We default any insoluble CallStacks to the empty CallStack. Suppose-   `undefined` did not request a CallStack, ie--     undefinedNoStk :: a-     undefinedNoStk = error "undefined!"--   Under the usual IP rules, the new wanted from rule (2) would be-   insoluble as there's no given IP from which to solve it, so we-   would get an "unbound implicit parameter" error.--   We don't ever want to emit an insoluble CallStack IP, so we add a-   defaulting pass to default any remaining wanted CallStacks to the-   empty CallStack with the evidence term--     EvCsEmpty--   (see TcSimplify.simpl_top and TcSimplify.defaultCallStacks)--This provides a lightweight mechanism for building up call-stacks-explicitly, but is notably limited by the fact that the stack will-stop at the first function whose type does not include a CallStack IP.-For example, using the above definition of `undefined`:--  head :: [a] -> a-  head []    = undefined-  head (x:_) = x--  g = head []--the resulting CallStack will include the call to `undefined` in `head`-and the call to `error` in `undefined`, but *not* the call to `head`-in `g`, because `head` did not explicitly request a CallStack.---Important Details:-- GHC should NEVER report an insoluble CallStack constraint.--- GHC should NEVER infer a CallStack constraint unless one was requested-  with a partial type signature (See TcType.pickQuantifiablePreds).--- A CallStack (defined in GHC.Stack.Types) is a [(String, SrcLoc)],-  where the String is the name of the binder that is used at the-  SrcLoc. SrcLoc is also defined in GHC.Stack.Types and contains the-  package/module/file name, as well as the full source-span. Both-  CallStack and SrcLoc are kept abstract so only GHC can construct new-  values.--- We will automatically solve any wanted CallStack regardless of the-  name of the IP, i.e.--    f = show (?stk :: CallStack)-    g = show (?loc :: CallStack)--  are both valid. However, we will only push new SrcLocs onto existing-  CallStacks when the IP names match, e.g. in--    head :: (?loc :: CallStack) => [a] -> a-    head [] = error (show (?stk :: CallStack))--  the printed CallStack will NOT include head's call-site. This reflects the-  standard scoping rules of implicit-parameters.--- 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 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`-  (see TcInteract.interactDict).--  This is a bit shady, but is how we ensure that the new wanted is-  solved like a regular IP.---}--mkEvCast :: EvExpr -> TcCoercion -> EvTerm-mkEvCast ev lco-  | ASSERT2( tcCoercionRole lco == Representational-           , (vcat [text "Coercion of wrong role passed to mkEvCast:", ppr ev, ppr lco]))-    isTcReflCo lco = EvExpr ev-  | otherwise      = evCast ev lco---mkEvScSelectors         -- Assume   class (..., D ty, ...) => C a b-  :: Class -> [TcType]  -- C ty1 ty2-  -> [(TcPredType,      -- D ty[ty1/a,ty2/b]-       EvExpr)          -- :: C ty1 ty2 -> D ty[ty1/a,ty2/b]-     ]-mkEvScSelectors cls tys-   = zipWith mk_pr (immSuperClasses cls tys) [0..]-  where-    mk_pr pred i = (pred, Var sc_sel_id `mkTyApps` tys)-      where-        sc_sel_id  = classSCSelId cls i -- Zero-indexed--emptyTcEvBinds :: TcEvBinds-emptyTcEvBinds = EvBinds emptyBag--isEmptyTcEvBinds :: TcEvBinds -> Bool-isEmptyTcEvBinds (EvBinds b)    = isEmptyBag b-isEmptyTcEvBinds (TcEvBinds {}) = panic "isEmptyTcEvBinds"--evTermCoercion_maybe :: EvTerm -> Maybe TcCoercion--- Applied only to EvTerms of type (s~t)--- See Note [Coercion evidence terms]-evTermCoercion_maybe ev_term-  | EvExpr e <- ev_term = go e-  | otherwise           = Nothing-  where-    go :: EvExpr -> Maybe TcCoercion-    go (Var v)       = return (mkCoVarCo v)-    go (Coercion co) = return co-    go (Cast tm co)  = do { co' <- go tm-                          ; return (mkCoCast co' co) }-    go _             = Nothing--evTermCoercion :: EvTerm -> TcCoercion-evTermCoercion tm = case evTermCoercion_maybe tm of-                      Just co -> co-                      Nothing -> pprPanic "evTermCoercion" (ppr tm)---{- *********************************************************************-*                                                                      *-                  Free variables-*                                                                      *-********************************************************************* -}--findNeededEvVars :: EvBindMap -> VarSet -> VarSet--- Find all the Given evidence needed by seeds,--- looking transitively through binds-findNeededEvVars ev_binds seeds-  = transCloVarSet also_needs seeds-  where-   also_needs :: VarSet -> VarSet-   also_needs needs = nonDetFoldUniqSet add emptyVarSet needs-     -- It's OK to use nonDetFoldUFM here because we immediately-     -- forget about the ordering by creating a set--   add :: Var -> VarSet -> VarSet-   add v needs-     | Just ev_bind <- lookupEvBind ev_binds v-     , EvBind { eb_is_given = is_given, eb_rhs = rhs } <- ev_bind-     , is_given-     = evVarsOfTerm rhs `unionVarSet` needs-     | otherwise-     = needs--evVarsOfTerm :: EvTerm -> VarSet-evVarsOfTerm (EvExpr e)         = exprSomeFreeVars isEvVar e-evVarsOfTerm (EvTypeable _ ev)  = evVarsOfTypeable ev-evVarsOfTerm (EvFun {})         = emptyVarSet -- See Note [Free vars of EvFun]--evVarsOfTerms :: [EvTerm] -> VarSet-evVarsOfTerms = mapUnionVarSet evVarsOfTerm--evVarsOfTypeable :: EvTypeable -> VarSet-evVarsOfTypeable ev =-  case ev of-    EvTypeableTyCon _ e   -> mapUnionVarSet evVarsOfTerm e-    EvTypeableTyApp e1 e2 -> evVarsOfTerms [e1,e2]-    EvTypeableTrFun e1 e2 -> evVarsOfTerms [e1,e2]-    EvTypeableTyLit e     -> evVarsOfTerm e---{- Note [Free vars of EvFun]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Finding the free vars of an EvFun is made tricky by the fact the-bindings et_binds may be a mutable variable.  Fortunately, we-can just squeeze by.  Here's how.--* evVarsOfTerm is used only by TcSimplify.neededEvVars.-* Each EvBindsVar in an et_binds field of an EvFun is /also/ in the-  ic_binds field of an Implication-* So we can track usage via the processing for that implication,-  (see Note [Tracking redundant constraints] in TcSimplify).-  We can ignore usage from the EvFun altogether.--************************************************************************-*                                                                      *-                  Pretty printing-*                                                                      *-************************************************************************--}--instance Outputable HsWrapper where-  ppr co_fn = pprHsWrapper co_fn (no_parens (text "<>"))--pprHsWrapper :: HsWrapper -> (Bool -> SDoc) -> SDoc--- With -fprint-typechecker-elaboration, print the wrapper---   otherwise just print what's inside--- 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-  = 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-    -- False <=> appears as body of let or lambda-    help it WpHole             = it-    help it (WpCompose f1 f2)  = help (help it f2) f1-    help it (WpFun f1 f2 t1 _) = add_parens $ text "\\(x" <> dcolon <> ppr t1 <> text ")." <+>-                                              help (\_ -> it True <+> help (\_ -> text "x") f1 True) f2 False-    help it (WpCast co)   = add_parens $ sep [it False, nest 2 (text "|>"-                                              <+> pprParendCo co)]-    help it (WpEvApp id)  = no_parens  $ sep [it True, nest 2 (ppr id)]-    help it (WpTyApp ty)  = no_parens  $ sep [it True, text "@" <> pprParendType ty]-    help it (WpEvLam id)  = add_parens $ sep [ text "\\" <> pprLamBndr id <> dot, it False]-    help it (WpTyLam tv)  = add_parens $ sep [text "/\\" <> pprLamBndr tv <> dot, it False]-    help it (WpLet binds) = add_parens $ sep [text "let" <+> braces (ppr binds), it False]--pprLamBndr :: Id -> SDoc-pprLamBndr v = pprBndr LambdaBind v--add_parens, no_parens :: SDoc -> Bool -> SDoc-add_parens d True  = parens d-add_parens d False = d-no_parens d _ = d--instance Outputable TcEvBinds where-  ppr (TcEvBinds v) = ppr v-  ppr (EvBinds bs)  = text "EvBinds" <> braces (vcat (map ppr (bagToList bs)))--instance Outputable EvBindsVar where-  ppr (EvBindsVar { ebv_uniq = u })-     = text "EvBindsVar" <> angleBrackets (ppr u)-  ppr (CoEvBindsVar { ebv_uniq = u })-     = text "CoEvBindsVar" <> angleBrackets (ppr u)--instance Uniquable EvBindsVar where-  getUnique = ebv_uniq--instance Outputable EvBind where-  ppr (EvBind { eb_lhs = v, eb_rhs = e, eb_is_given = is_given })-     = sep [ pp_gw <+> ppr v-           , nest 2 $ equals <+> ppr e ]-     where-       pp_gw = brackets (if is_given then char 'G' else char 'W')-   -- We cheat a bit and pretend EqVars are CoVars for the purposes of pretty printing--instance Outputable EvTerm where-  ppr (EvExpr e)         = ppr e-  ppr (EvTypeable ty ev) = ppr ev <+> dcolon <+> text "Typeable" <+> ppr ty-  ppr (EvFun { et_tvs = tvs, et_given = gs, et_binds = bs, et_body = w })-      = hang (text "\\" <+> sep (map pprLamBndr (tvs ++ gs)) <+> arrow)-           2 (ppr bs $$ ppr w)   -- Not very pretty--instance Outputable EvCallStack where-  ppr EvCsEmpty-    = text "[]"-  ppr (EvCsPushCall name loc tm)-    = ppr (name,loc) <+> text ":" <+> ppr tm--instance Outputable EvTypeable where-  ppr (EvTypeableTyCon ts _)  = text "TyCon" <+> ppr ts-  ppr (EvTypeableTyApp t1 t2) = parens (ppr t1 <+> ppr t2)-  ppr (EvTypeableTrFun t1 t2) = parens (ppr t1 <+> arrow <+> ppr t2)-  ppr (EvTypeableTyLit t1)    = text "TyLit" <> ppr t1---------------------------------------------------------------------------- Helper functions for dealing with IP newtype-dictionaries--------------------------------------------------------------------------- | Create a 'Coercion' that unwraps an implicit-parameter or--- overloaded-label dictionary to expose the underlying value. We--- expect the 'Type' to have the form `IP sym ty` or `IsLabel sym ty`,--- and return a 'Coercion' `co :: IP sym ty ~ ty` or--- `co :: IsLabel sym ty ~ Proxy# sym -> ty`.  See also--- Note [Type-checking overloaded labels] in TcExpr.-unwrapIP :: Type -> CoercionR-unwrapIP ty =-  case unwrapNewTyCon_maybe tc of-    Just (_,_,ax) -> mkUnbranchedAxInstCo Representational ax tys []-    Nothing       -> pprPanic "unwrapIP" $-                       text "The dictionary for" <+> quotes (ppr tc)-                         <+> text "is not a newtype!"-  where-  (tc, tys) = splitTyConApp ty---- | Create a 'Coercion' that wraps a value in an implicit-parameter--- dictionary. See 'unwrapIP'.-wrapIP :: Type -> CoercionR-wrapIP ty = mkSymCo (unwrapIP ty)--------------------------------------------------------------------------- A datatype used to pass information when desugaring quotations--------------------------------------------------------------------------- We have to pass a `EvVar` and `Type` into `dsBracket` so that the--- correct evidence and types are applied to all the TH combinators.--- This data type bundles them up together with some convenience methods.------ The EvVar is evidence for `Quote m`--- The Type is a metavariable for `m`----data QuoteWrapper = QuoteWrapper EvVar Type deriving Data.Data--quoteWrapperTyVarTy :: QuoteWrapper -> Type-quoteWrapperTyVarTy (QuoteWrapper _ t) = t---- | Convert the QuoteWrapper into a normal HsWrapper which can be used to--- apply its contents.-applyQuoteWrapper :: QuoteWrapper -> HsWrapper-applyQuoteWrapper (QuoteWrapper ev_var m_var)-  = mkWpEvVarApps [ev_var] <.> mkWpTyApps [m_var]
− compiler/typecheck/TcHoleFitTypes.hs 
@@ -1,145 +0,0 @@-{-# LANGUAGE ExistentialQuantification #-}-module TcHoleFitTypes (-  TypedHole (..), HoleFit (..), HoleFitCandidate (..),-  CandPlugin, FitPlugin, HoleFitPlugin (..), HoleFitPluginR (..),-  hfIsLcl, pprHoleFitCand-  ) where--import GhcPrelude--import TcRnTypes-import Constraint-import TcType--import GHC.Types.Name.Reader--import GHC.Hs.Doc-import GHC.Types.Id--import Outputable-import GHC.Types.Name--import Data.Function ( on )--data TypedHole = TyH { tyHRelevantCts :: Cts-                       -- ^ Any relevant Cts to the hole-                     , tyHImplics :: [Implication]-                       -- ^ The nested implications of the hole with the-                       --   innermost implication first.-                     , tyHCt :: Maybe Ct-                       -- ^ The hole constraint itself, if available.-                     }--instance Outputable TypedHole where-  ppr (TyH rels implics ct)-    = hang (text "TypedHole") 2-        (ppr rels $+$ ppr implics $+$ ppr ct)----- | HoleFitCandidates are passed to hole fit plugins and then--- checked whether they fit a given typed-hole.-data HoleFitCandidate = IdHFCand Id             -- An id, like locals.-                      | NameHFCand Name         -- A name, like built-in syntax.-                      | GreHFCand GlobalRdrElt  -- A global, like imported ids.-                      deriving (Eq)--instance Outputable HoleFitCandidate where-  ppr = pprHoleFitCand--pprHoleFitCand :: HoleFitCandidate -> SDoc-pprHoleFitCand (IdHFCand cid) = text "Id HFC: " <> ppr cid-pprHoleFitCand (NameHFCand cname) = text "Name HFC: " <> ppr cname-pprHoleFitCand (GreHFCand cgre) = text "Gre HFC: " <> ppr cgre-----instance NamedThing HoleFitCandidate where-  getName hfc = case hfc of-                     IdHFCand cid -> idName cid-                     NameHFCand cname -> cname-                     GreHFCand cgre -> gre_name cgre-  getOccName hfc = case hfc of-                     IdHFCand cid -> occName cid-                     NameHFCand cname -> occName cname-                     GreHFCand cgre -> occName (gre_name cgre)--instance HasOccName HoleFitCandidate where-  occName = getOccName--instance Ord HoleFitCandidate where-  compare = compare `on` getName---- | HoleFit is the type we use for valid hole fits. It contains the--- element that was checked, the Id of that element as found by `tcLookup`,--- and the refinement level of the fit, which is the number of extra argument--- holes that this fit uses (e.g. if hfRefLvl is 2, the fit is for `Id _ _`).-data HoleFit =-  HoleFit { hfId   :: Id       -- ^ The elements id in the TcM-          , hfCand :: HoleFitCandidate  -- ^ The candidate that was checked.-          , hfType :: TcType -- ^ The type of the id, possibly zonked.-          , hfRefLvl :: Int  -- ^ The number of holes in this fit.-          , hfWrap :: [TcType] -- ^ The wrapper for the match.-          , hfMatches :: [TcType]-          -- ^ What the refinement variables got matched with, if anything-          , hfDoc :: Maybe HsDocString-          -- ^ Documentation of this HoleFit, if available.-          }- | RawHoleFit SDoc- -- ^ A fit that is just displayed as is. Here so thatHoleFitPlugins- --   can inject any fit they want.---- We define an Eq and Ord instance to be able to build a graph.-instance Eq HoleFit where-   (==) = (==) `on` hfId--instance Outputable HoleFit where-  ppr (RawHoleFit sd) = sd-  ppr (HoleFit _ cand ty _ _ mtchs _) =-    hang (name <+> holes) 2 (text "where" <+> name <+> dcolon <+> (ppr ty))-    where name = ppr $ getName cand-          holes = sep $ map (parens . (text "_" <+> dcolon <+>) . ppr) mtchs---- We compare HoleFits by their name instead of their Id, since we don't--- want our tests to be affected by the non-determinism of `nonDetCmpVar`,--- which is used to compare Ids. When comparing, we want HoleFits with a lower--- refinement level to come first.-instance Ord HoleFit where-  compare (RawHoleFit _) (RawHoleFit _) = EQ-  compare (RawHoleFit _) _ = LT-  compare _ (RawHoleFit _) = GT-  compare a@(HoleFit {}) b@(HoleFit {}) = cmp a b-    where cmp  = if hfRefLvl a == hfRefLvl b-                 then compare `on` (getName . hfCand)-                 else compare `on` hfRefLvl--hfIsLcl :: HoleFit -> Bool-hfIsLcl hf@(HoleFit {}) = case hfCand hf of-                            IdHFCand _    -> True-                            NameHFCand _  -> False-                            GreHFCand gre -> gre_lcl gre-hfIsLcl _ = False----- | A plugin for modifying the candidate hole fits *before* they're checked.-type CandPlugin = TypedHole -> [HoleFitCandidate] -> TcM [HoleFitCandidate]---- | A plugin for modifying hole fits  *after* they've been found.-type FitPlugin =  TypedHole -> [HoleFit] -> TcM [HoleFit]---- | A HoleFitPlugin is a pair of candidate and fit plugins.-data HoleFitPlugin = HoleFitPlugin-  { candPlugin :: CandPlugin-  , fitPlugin :: FitPlugin }---- | HoleFitPluginR adds a TcRef to hole fit plugins so that plugins can--- track internal state. Note the existential quantification, ensuring that--- the state cannot be modified from outside the plugin.-data HoleFitPluginR = forall s. HoleFitPluginR-  { hfPluginInit :: TcM (TcRef s)-    -- ^ Initializes the TcRef to be passed to the plugin-  , hfPluginRun :: TcRef s -> HoleFitPlugin-    -- ^ The function defining the plugin itself-  , hfPluginStop :: TcRef s -> TcM ()-    -- ^ Cleanup of state, guaranteed to be called even on error-  }
− compiler/typecheck/TcHoleFitTypes.hs-boot 
@@ -1,10 +0,0 @@--- This boot file is in place to break the loop where:--- + TcRnTypes needs 'HoleFitPlugin',--- + which needs 'TcHoleFitTypes'--- + which needs 'TcRnTypes'-module TcHoleFitTypes where---- Build ordering-import GHC.Base()--data HoleFitPlugin
− compiler/typecheck/TcOrigin.hs 
@@ -1,656 +0,0 @@-{---Describes the provenance of types as they flow through the type-checker.-The datatypes here are mainly used for error message generation.---}--{-# LANGUAGE CPP #-}-{-# LANGUAGE LambdaCase #-}--{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns   #-}--module TcOrigin (-  -- UserTypeCtxt-  UserTypeCtxt(..), pprUserTypeCtxt, isSigMaybe,--  -- SkolemInfo-  SkolemInfo(..), pprSigSkolInfo, pprSkolInfo,--  -- CtOrigin-  CtOrigin(..), exprCtOrigin, lexprCtOrigin, matchesCtOrigin, grhssCtOrigin,-  isVisibleOrigin, toInvisibleOrigin,-  pprCtOrigin, isGivenOrigin--  ) where--#include "HsVersions.h"--import GhcPrelude--import TcType--import GHC.Hs--import GHC.Types.Id-import GHC.Core.DataCon-import GHC.Core.ConLike-import GHC.Core.TyCon-import GHC.Core.InstEnv-import GHC.Core.PatSyn--import GHC.Types.Module-import GHC.Types.Name-import GHC.Types.Name.Reader--import GHC.Types.SrcLoc-import FastString-import Outputable-import GHC.Types.Basic--{- *********************************************************************-*                                                                      *-          UserTypeCtxt-*                                                                      *-********************************************************************* -}------------------------------------------ | UserTypeCtxt describes the origin of the polymorphic type--- in the places where we need an expression to have that type-data UserTypeCtxt-  = FunSigCtxt      -- Function type signature, when checking the type-                    -- Also used for types in SPECIALISE pragmas-       Name              -- Name of the function-       Bool              -- True <=> report redundant constraints-                            -- This is usually True, but False for-                            --   * Record selectors (not important here)-                            --   * Class and instance methods.  Here-                            --     the code may legitimately be more-                            --     polymorphic than the signature-                            --     generated from the class-                            --     declaration--  | InfSigCtxt Name     -- Inferred type for function-  | ExprSigCtxt         -- Expression type signature-  | KindSigCtxt         -- Kind signature-  | StandaloneKindSigCtxt  -- Standalone kind signature-       Name                -- Name of the type/class-  | TypeAppCtxt         -- Visible type application-  | ConArgCtxt Name     -- Data constructor argument-  | TySynCtxt Name      -- RHS of a type synonym decl-  | PatSynCtxt Name     -- Type sig for a pattern synonym-  | PatSigCtxt          -- Type sig in pattern-                        --   eg  f (x::t) = ...-                        --   or  (x::t, y) = e-  | RuleSigCtxt Name    -- LHS of a RULE forall-                        --    RULE "foo" forall (x :: a -> a). f (Just x) = ...-  | ResSigCtxt          -- Result type sig-                        --      f x :: t = ....-  | ForSigCtxt Name     -- Foreign import or export signature-  | DefaultDeclCtxt     -- Types in a default declaration-  | InstDeclCtxt Bool   -- An instance declaration-                        --    True:  stand-alone deriving-                        --    False: vanilla instance declaration-  | SpecInstCtxt        -- SPECIALISE instance pragma-  | ThBrackCtxt         -- Template Haskell type brackets [t| ... |]-  | GenSigCtxt          -- Higher-rank or impredicative situations-                        -- e.g. (f e) where f has a higher-rank type-                        -- We might want to elaborate this-  | GhciCtxt Bool       -- GHCi command :kind <type>-                        -- The Bool indicates if we are checking the outermost-                        -- type application.-                        -- See Note [Unsaturated type synonyms in GHCi] in-                        -- TcValidity.--  | ClassSCCtxt Name    -- Superclasses of a class-  | SigmaCtxt           -- Theta part of a normal for-all type-                        --      f :: <S> => a -> a-  | DataTyCtxt Name     -- The "stupid theta" part of a data decl-                        --      data <S> => T a = MkT a-  | DerivClauseCtxt     -- A 'deriving' clause-  | TyVarBndrKindCtxt Name  -- The kind of a type variable being bound-  | DataKindCtxt Name   -- The kind of a data/newtype (instance)-  | TySynKindCtxt Name  -- The kind of the RHS of a type synonym-  | TyFamResKindCtxt Name   -- The result kind of a type family--{---- Notes re TySynCtxt--- We allow type synonyms that aren't types; e.g.  type List = []------ If the RHS mentions tyvars that aren't in scope, we'll--- quantify over them:---      e.g.    type T = a->a--- will become  type T = forall a. a->a------ With gla-exts that's right, but for H98 we should complain.--}---pprUserTypeCtxt :: UserTypeCtxt -> SDoc-pprUserTypeCtxt (FunSigCtxt n _)  = text "the type signature for" <+> quotes (ppr n)-pprUserTypeCtxt (InfSigCtxt n)    = text "the inferred type for" <+> quotes (ppr n)-pprUserTypeCtxt (RuleSigCtxt n)   = text "a RULE for" <+> quotes (ppr n)-pprUserTypeCtxt ExprSigCtxt       = text "an expression type signature"-pprUserTypeCtxt KindSigCtxt       = text "a kind signature"-pprUserTypeCtxt (StandaloneKindSigCtxt n) = text "a standalone kind signature for" <+> quotes (ppr n)-pprUserTypeCtxt TypeAppCtxt       = text "a type argument"-pprUserTypeCtxt (ConArgCtxt c)    = text "the type of the constructor" <+> quotes (ppr c)-pprUserTypeCtxt (TySynCtxt c)     = text "the RHS of the type synonym" <+> quotes (ppr c)-pprUserTypeCtxt ThBrackCtxt       = text "a Template Haskell quotation [t|...|]"-pprUserTypeCtxt PatSigCtxt        = text "a pattern type signature"-pprUserTypeCtxt ResSigCtxt        = text "a result type signature"-pprUserTypeCtxt (ForSigCtxt n)    = text "the foreign declaration for" <+> quotes (ppr n)-pprUserTypeCtxt DefaultDeclCtxt   = text "a type in a `default' declaration"-pprUserTypeCtxt (InstDeclCtxt False) = text "an instance declaration"-pprUserTypeCtxt (InstDeclCtxt True)  = text "a stand-alone deriving instance declaration"-pprUserTypeCtxt SpecInstCtxt      = text "a SPECIALISE instance pragma"-pprUserTypeCtxt GenSigCtxt        = text "a type expected by the context"-pprUserTypeCtxt (GhciCtxt {})     = text "a type in a GHCi command"-pprUserTypeCtxt (ClassSCCtxt c)   = text "the super-classes of class" <+> quotes (ppr c)-pprUserTypeCtxt SigmaCtxt         = text "the context of a polymorphic type"-pprUserTypeCtxt (DataTyCtxt tc)   = text "the context of the data type declaration for" <+> quotes (ppr tc)-pprUserTypeCtxt (PatSynCtxt n)    = text "the signature for pattern synonym" <+> quotes (ppr n)-pprUserTypeCtxt (DerivClauseCtxt) = text "a `deriving' clause"-pprUserTypeCtxt (TyVarBndrKindCtxt n) = text "the kind annotation on the type variable" <+> quotes (ppr n)-pprUserTypeCtxt (DataKindCtxt n)  = text "the kind annotation on the declaration for" <+> quotes (ppr n)-pprUserTypeCtxt (TySynKindCtxt n) = text "the kind annotation on the declaration for" <+> quotes (ppr n)-pprUserTypeCtxt (TyFamResKindCtxt n) = text "the result kind for" <+> quotes (ppr n)--isSigMaybe :: UserTypeCtxt -> Maybe Name-isSigMaybe (FunSigCtxt n _) = Just n-isSigMaybe (ConArgCtxt n)   = Just n-isSigMaybe (ForSigCtxt n)   = Just n-isSigMaybe (PatSynCtxt n)   = Just n-isSigMaybe _                = Nothing--{--************************************************************************-*                                                                      *-                SkolemInfo-*                                                                      *-************************************************************************--}---- SkolemInfo gives the origin of *given* constraints---   a) type variables are skolemised---   b) an implication constraint is generated-data SkolemInfo-  = SigSkol -- A skolem that is created by instantiating-            -- a programmer-supplied type signature-            -- Location of the binding site is on the TyVar-            -- See Note [SigSkol SkolemInfo]-       UserTypeCtxt        -- What sort of signature-       TcType              -- Original type signature (before skolemisation)-       [(Name,TcTyVar)]    -- Maps the original name of the skolemised tyvar-                           -- to its instantiated version--  | SigTypeSkol UserTypeCtxt-                 -- like SigSkol, but when we're kind-checking the *type*-                 -- hence, we have less info--  | ForAllSkol SDoc     -- Bound by a user-written "forall".--  | DerivSkol Type      -- Bound by a 'deriving' clause;-                        -- the type is the instance we are trying to derive--  | InstSkol            -- Bound at an instance decl-  | InstSC TypeSize     -- A "given" constraint obtained by superclass selection.-                        -- If (C ty1 .. tyn) is the largest class from-                        --    which we made a superclass selection in the chain,-                        --    then TypeSize = sizeTypes [ty1, .., tyn]-                        -- See Note [Solving superclass constraints] in TcInstDcls--  | 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 GhcRn)-             -- e.g.   data T = forall a. Eq a => MkT a-             --        f (MkT x) = ...-             -- The pattern MkT x will allocate an existential type-             -- variable for 'a'.--  | ArrowSkol           -- An arrow form (see TcArrows)--  | IPSkol [HsIPName]   -- Binding site of an implicit parameter--  | RuleSkol RuleName   -- The LHS of a RULE--  | InferSkol [(Name,TcType)]-                        -- We have inferred a type for these (mutually-recursivive)-                        -- polymorphic Ids, and are now checking that their RHS-                        -- constraints are satisfied.--  | BracketSkol         -- Template Haskell bracket--  | UnifyForAllSkol     -- We are unifying two for-all types-       TcType           -- The instantiated type *inside* the forall--  | TyConSkol TyConFlavour Name  -- bound in a type declaration of the given flavour--  | DataConSkol Name    -- bound as an existential in a Haskell98 datacon decl or-                        -- as any variable in a GADT datacon decl--  | ReifySkol           -- Bound during Template Haskell reification--  | 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-  ppr = pprSkolInfo--pprSkolInfo :: SkolemInfo -> SDoc--- Complete the sentence "is a rigid type variable bound by..."-pprSkolInfo (SigSkol cx ty _) = pprSigSkolInfo cx ty-pprSkolInfo (SigTypeSkol cx)  = pprUserTypeCtxt cx-pprSkolInfo (ForAllSkol doc)  = quotes doc-pprSkolInfo (IPSkol ips)      = text "the implicit-parameter binding" <> plural ips <+> text "for"-                                 <+> pprWithCommas ppr ips-pprSkolInfo (DerivSkol pred)  = text "the deriving clause for" <+> quotes (ppr pred)-pprSkolInfo InstSkol          = text "the instance declaration"-pprSkolInfo (InstSC n)        = text "the instance declaration" <> whenPprDebug (parens (ppr n))-pprSkolInfo FamInstSkol       = text "a family instance declaration"-pprSkolInfo BracketSkol       = text "a Template Haskell bracket"-pprSkolInfo (RuleSkol name)   = text "the RULE" <+> pprRuleName name-pprSkolInfo ArrowSkol         = text "an arrow form"-pprSkolInfo (PatSkol cl mc)   = sep [ pprPatSkolInfo cl-                                    , text "in" <+> pprMatchContext mc ]-pprSkolInfo (InferSkol ids)   = hang (text "the inferred type" <> plural ids <+> text "of")-                                   2 (vcat [ ppr name <+> dcolon <+> ppr ty-                                                   | (name,ty) <- ids ])-pprSkolInfo (UnifyForAllSkol ty) = text "the type" <+> ppr ty-pprSkolInfo (TyConSkol flav name) = text "the" <+> ppr flav <+> text "declaration for" <+> quotes (ppr name)-pprSkolInfo (DataConSkol name)= text "the data constructor" <+> quotes (ppr name)-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.--- For Insts, these cases should not happen-pprSkolInfo UnkSkol = WARN( True, text "pprSkolInfo: UnkSkol" ) text "UnkSkol"--pprSigSkolInfo :: UserTypeCtxt -> TcType -> SDoc--- The type is already tidied-pprSigSkolInfo ctxt ty-  = case ctxt of-       FunSigCtxt f _ -> vcat [ text "the type signature for:"-                              , nest 2 (pprPrefixOcc f <+> dcolon <+> ppr ty) ]-       PatSynCtxt {}  -> pprUserTypeCtxt ctxt  -- See Note [Skolem info for pattern synonyms]-       _              -> vcat [ pprUserTypeCtxt ctxt <> colon-                              , nest 2 (ppr ty) ]--pprPatSkolInfo :: ConLike -> SDoc-pprPatSkolInfo (RealDataCon dc)-  = sep [ text "a pattern with constructor:"-        , nest 2 $ ppr dc <+> dcolon-          <+> pprType (dataConUserType dc) <> comma ]-          -- pprType prints forall's regardless of -fprint-explicit-foralls-          -- which is what we want here, since we might be saying-          -- type variable 't' is bound by ...--pprPatSkolInfo (PatSynCon ps)-  = sep [ text "a pattern with pattern synonym:"-        , nest 2 $ ppr ps <+> dcolon-                   <+> pprPatSynType ps <> comma ]--{- Note [Skolem info for pattern synonyms]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-For pattern synonym SkolemInfo we have-   SigSkol (PatSynCtxt p) ty _-but the type 'ty' is not very helpful.  The full pattern-synonym type-has the provided and required pieces, which it is inconvenient to-record and display here. So we simply don't display the type at all,-contenting outselves with just the name of the pattern synonym, which-is fine.  We could do more, but it doesn't seem worth it.--Note [SigSkol SkolemInfo]-~~~~~~~~~~~~~~~~~~~~~~~~~-Suppose we (deeply) skolemise a type-   f :: forall a. a -> forall b. b -> a-Then we'll instantiate [a :-> a', b :-> b'], and with the instantiated-      a' -> b' -> a.-But when, in an error message, we report that "b is a rigid type-variable bound by the type signature for f", we want to show the foralls-in the right place.  So we proceed as follows:--* In SigSkol we record-    - the original signature forall a. a -> forall b. b -> a-    - the instantiation mapping [a :-> a', b :-> b']--* Then when tidying in TcMType.tidySkolemInfo, we first tidy a' to-  whatever it tidies to, say a''; and then we walk over the type-  replacing the binder a by the tidied version a'', to give-       forall a''. a'' -> forall b''. b'' -> a''-  We need to do this under function arrows, to match what deeplySkolemise-  does.--* Typically a'' will have a nice pretty name like "a", but the point is-  that the foral-bound variables of the signature we report line up with-  the instantiated skolems lying  around in other types.---************************************************************************-*                                                                      *-            CtOrigin-*                                                                      *-************************************************************************--}--data CtOrigin-  = GivenOrigin SkolemInfo--  -- All the others are for *wanted* constraints-  | OccurrenceOf Name              -- Occurrence of an overloaded identifier-  | OccurrenceOfRecSel RdrName     -- Occurrence of a record selector-  | AppOrigin                      -- An application of some kind--  | SpecPragOrigin UserTypeCtxt    -- Specialisation pragma for-                                   -- function or instance--  | TypeEqOrigin { uo_actual   :: TcType-                 , uo_expected :: TcType-                 , uo_thing    :: Maybe SDoc-                       -- ^ The thing that has type "actual"-                 , uo_visible  :: Bool-                       -- ^ Is at least one of the three elements above visible?-                       -- (Errors from the polymorphic subsumption check are considered-                       -- visible.) Only used for prioritizing error messages.-                 }--  | KindEqOrigin-      TcType (Maybe TcType)     -- A kind equality arising from unifying these two types-      CtOrigin                  -- originally arising from this-      (Maybe TypeOrKind)        -- the level of the eq this arises from--  | IPOccOrigin  HsIPName       -- Occurrence of an implicit parameter-  | OverLabelOrigin FastString  -- Occurrence of an overloaded label--  | LiteralOrigin (HsOverLit GhcRn)     -- Occurrence of a literal-  | NegateOrigin                        -- Occurrence of syntactic negation--  | ArithSeqOrigin (ArithSeqInfo GhcRn) -- [x..], [x..y] etc-  | AssocFamPatOrigin   -- When matching the patterns of an associated-                        -- family instance with that of its parent class-  | SectionOrigin-  | TupleOrigin         -- (..,..)-  | ExprSigOrigin       -- e :: ty-  | PatSigOrigin        -- p :: ty-  | PatOrigin           -- Instantiating a polytyped pattern at a constructor-  | ProvCtxtOrigin      -- The "provided" context of a pattern synonym signature-        (PatSynBind GhcRn GhcRn) -- Information about the pattern synonym, in-                                 -- particular the name and the right-hand side-  | RecordUpdOrigin-  | ViewPatOrigin--  | ScOrigin TypeSize   -- Typechecking superclasses of an instance declaration-                        -- If the instance head is C ty1 .. tyn-                        --    then TypeSize = sizeTypes [ty1, .., tyn]-                        -- See Note [Solving superclass constraints] in TcInstDcls--  | DerivClauseOrigin   -- Typechecking a deriving clause (as opposed to-                        -- standalone deriving).-  | DerivOriginDC DataCon Int Bool-      -- Checking constraints arising from this data con and field index. The-      -- Bool argument in DerivOriginDC and DerivOriginCoerce is True if-      -- standalong deriving (with a wildcard constraint) is being used. This-      -- is used to inform error messages on how to recommended fixes (e.g., if-      -- the argument is True, then don't recommend "use standalone deriving",-      -- but rather "fill in the wildcard constraint yourself").-      -- See Note [Inferring the instance context] in TcDerivInfer-  | DerivOriginCoerce Id Type Type Bool-                        -- DerivOriginCoerce id ty1 ty2: Trying to coerce class method `id` from-                        -- `ty1` to `ty2`.-  | StandAloneDerivOrigin -- Typechecking stand-alone deriving. Useful for-                          -- constraints coming from a wildcard constraint,-                          -- e.g., deriving instance _ => Eq (Foo a)-                          -- See Note [Inferring the instance context]-                          -- in TcDerivInfer-  | DefaultOrigin       -- Typechecking a default decl-  | DoOrigin            -- Arising from a do expression-  | DoPatOrigin (LPat GhcRn) -- Arising from a failable pattern in-                             -- a do expression-  | MCompOrigin         -- Arising from a monad comprehension-  | MCompPatOrigin (LPat GhcRn) -- Arising from a failable pattern in a-                                -- monad comprehension-  | IfOrigin            -- Arising from an if statement-  | ProcOrigin          -- Arising from a proc expression-  | AnnOrigin           -- An annotation--  | FunDepOrigin1       -- A functional dependency from combining-        PredType CtOrigin RealSrcSpan      -- This constraint arising from ...-        PredType CtOrigin RealSrcSpan      -- and this constraint arising from ...--  | FunDepOrigin2       -- A functional dependency from combining-        PredType CtOrigin   -- This constraint arising from ...-        PredType SrcSpan    -- and this top-level instance-        -- We only need a CtOrigin on the first, because the location-        -- is pinned on the entire error message--  | HoleOrigin-  | UnboundOccurrenceOf OccName-  | ListOrigin          -- An overloaded list-  | BracketOrigin       -- An overloaded quotation bracket-  | StaticOrigin        -- A static form-  | Shouldn'tHappenOrigin String-                            -- the user should never see this one,-                            -- unless ImpredicativeTypes is on, where all-                            -- bets are off-  | InstProvidedOrigin Module ClsInst-        -- Skolem variable arose when we were testing if an instance-        -- is solvable or not.--- An origin is visible if the place where the constraint arises is manifest--- in user code. Currently, all origins are visible except for invisible--- TypeEqOrigins. This is used when choosing which error of--- several to report-isVisibleOrigin :: CtOrigin -> Bool-isVisibleOrigin (TypeEqOrigin { uo_visible = vis }) = vis-isVisibleOrigin (KindEqOrigin _ _ sub_orig _)       = isVisibleOrigin sub_orig-isVisibleOrigin _                                   = True---- Converts a visible origin to an invisible one, if possible. Currently,--- this works only for TypeEqOrigin-toInvisibleOrigin :: CtOrigin -> CtOrigin-toInvisibleOrigin orig@(TypeEqOrigin {}) = orig { uo_visible = False }-toInvisibleOrigin orig                   = orig--isGivenOrigin :: CtOrigin -> Bool-isGivenOrigin (GivenOrigin {})              = True-isGivenOrigin (FunDepOrigin1 _ o1 _ _ o2 _) = isGivenOrigin o1 && isGivenOrigin o2-isGivenOrigin (FunDepOrigin2 _ o1 _ _)      = isGivenOrigin o1-isGivenOrigin _                             = False--instance Outputable CtOrigin where-  ppr = pprCtOrigin--ctoHerald :: SDoc-ctoHerald = text "arising from"---- | Extract a suitable CtOrigin from a HsExpr-lexprCtOrigin :: LHsExpr GhcRn -> CtOrigin-lexprCtOrigin (L _ e) = exprCtOrigin e--exprCtOrigin :: HsExpr GhcRn -> CtOrigin-exprCtOrigin (HsVar _ (L _ name)) = OccurrenceOf name-exprCtOrigin (HsUnboundVar _ uv)  = UnboundOccurrenceOf uv-exprCtOrigin (HsConLikeOut {})    = panic "exprCtOrigin HsConLikeOut"-exprCtOrigin (HsRecFld _ f)    = OccurrenceOfRecSel (rdrNameAmbiguousFieldOcc f)-exprCtOrigin (HsOverLabel _ _ l)  = OverLabelOrigin l-exprCtOrigin (HsIPVar _ ip)       = IPOccOrigin ip-exprCtOrigin (HsOverLit _ lit)    = LiteralOrigin lit-exprCtOrigin (HsLit {})           = Shouldn'tHappenOrigin "concrete literal"-exprCtOrigin (HsLam _ matches)    = matchesCtOrigin matches-exprCtOrigin (HsLamCase _ ms)     = matchesCtOrigin ms-exprCtOrigin (HsApp _ e1 _)       = lexprCtOrigin e1-exprCtOrigin (HsAppType _ e1 _)   = lexprCtOrigin e1-exprCtOrigin (OpApp _ _ op _)     = lexprCtOrigin op-exprCtOrigin (NegApp _ e _)       = lexprCtOrigin e-exprCtOrigin (HsPar _ e)          = lexprCtOrigin e-exprCtOrigin (SectionL _ _ _)     = SectionOrigin-exprCtOrigin (SectionR _ _ _)     = SectionOrigin-exprCtOrigin (ExplicitTuple {})   = Shouldn'tHappenOrigin "explicit tuple"-exprCtOrigin ExplicitSum{}        = Shouldn'tHappenOrigin "explicit sum"-exprCtOrigin (HsCase _ _ matches) = matchesCtOrigin matches-exprCtOrigin (HsIf _ (SyntaxExprRn syn) _ _ _) = exprCtOrigin syn-exprCtOrigin (HsIf {})           = Shouldn'tHappenOrigin "if expression"-exprCtOrigin (HsMultiIf _ rhs)   = lGRHSCtOrigin rhs-exprCtOrigin (HsLet _ _ e)       = lexprCtOrigin e-exprCtOrigin (HsDo {})           = DoOrigin-exprCtOrigin (ExplicitList {})   = Shouldn'tHappenOrigin "list"-exprCtOrigin (RecordCon {})      = Shouldn'tHappenOrigin "record construction"-exprCtOrigin (RecordUpd {})      = Shouldn'tHappenOrigin "record update"-exprCtOrigin (ExprWithTySig {})  = ExprSigOrigin-exprCtOrigin (ArithSeq {})       = Shouldn'tHappenOrigin "arithmetic sequence"-exprCtOrigin (HsPragE _ _ e)     = lexprCtOrigin e-exprCtOrigin (HsBracket {})      = Shouldn'tHappenOrigin "TH bracket"-exprCtOrigin (HsRnBracketOut {})= Shouldn'tHappenOrigin "HsRnBracketOut"-exprCtOrigin (HsTcBracketOut {})= panic "exprCtOrigin HsTcBracketOut"-exprCtOrigin (HsSpliceE {})      = Shouldn'tHappenOrigin "TH splice"-exprCtOrigin (HsProc {})         = Shouldn'tHappenOrigin "proc"-exprCtOrigin (HsStatic {})       = Shouldn'tHappenOrigin "static expression"-exprCtOrigin (HsTick _ _ e)           = lexprCtOrigin e-exprCtOrigin (HsBinTick _ _ _ e)      = lexprCtOrigin e-exprCtOrigin (XExpr nec)        = noExtCon nec---- | Extract a suitable CtOrigin from a MatchGroup-matchesCtOrigin :: MatchGroup GhcRn (LHsExpr GhcRn) -> CtOrigin-matchesCtOrigin (MG { mg_alts = alts })-  | L _ [L _ match] <- alts-  , Match { m_grhss = grhss } <- match-  = grhssCtOrigin grhss--  | otherwise-  = Shouldn'tHappenOrigin "multi-way match"-matchesCtOrigin (XMatchGroup nec) = noExtCon nec---- | Extract a suitable CtOrigin from guarded RHSs-grhssCtOrigin :: GRHSs GhcRn (LHsExpr GhcRn) -> CtOrigin-grhssCtOrigin (GRHSs { grhssGRHSs = lgrhss }) = lGRHSCtOrigin lgrhss-grhssCtOrigin (XGRHSs nec) = noExtCon nec---- | Extract a suitable CtOrigin from a list of guarded RHSs-lGRHSCtOrigin :: [LGRHS GhcRn (LHsExpr GhcRn)] -> CtOrigin-lGRHSCtOrigin [L _ (GRHS _ _ (L _ e))] = exprCtOrigin e-lGRHSCtOrigin [L _ (XGRHS nec)] = noExtCon nec-lGRHSCtOrigin _ = Shouldn'tHappenOrigin "multi-way GRHS"--pprCtOrigin :: CtOrigin -> SDoc--- "arising from ..."--- Not an instance of Outputable because of the "arising from" prefix-pprCtOrigin (GivenOrigin sk) = ctoHerald <+> ppr sk--pprCtOrigin (SpecPragOrigin ctxt)-  = case ctxt of-       FunSigCtxt n _ -> text "for" <+> quotes (ppr n)-       SpecInstCtxt   -> text "a SPECIALISE INSTANCE pragma"-       _              -> text "a SPECIALISE pragma"  -- Never happens I think--pprCtOrigin (FunDepOrigin1 pred1 orig1 loc1 pred2 orig2 loc2)-  = hang (ctoHerald <+> text "a functional dependency between constraints:")-       2 (vcat [ hang (quotes (ppr pred1)) 2 (pprCtOrigin orig1 <+> text "at" <+> ppr loc1)-               , hang (quotes (ppr pred2)) 2 (pprCtOrigin orig2 <+> text "at" <+> ppr loc2) ])--pprCtOrigin (FunDepOrigin2 pred1 orig1 pred2 loc2)-  = hang (ctoHerald <+> text "a functional dependency between:")-       2 (vcat [ hang (text "constraint" <+> quotes (ppr pred1))-                    2 (pprCtOrigin orig1 )-               , hang (text "instance" <+> quotes (ppr pred2))-                    2 (text "at" <+> ppr loc2) ])--pprCtOrigin (KindEqOrigin t1 (Just t2) _ _)-  = hang (ctoHerald <+> text "a kind equality arising from")-       2 (sep [ppr t1, char '~', ppr t2])--pprCtOrigin AssocFamPatOrigin-  = text "when matching a family LHS with its class instance head"--pprCtOrigin (KindEqOrigin t1 Nothing _ _)-  = hang (ctoHerald <+> text "a kind equality when matching")-       2 (ppr t1)--pprCtOrigin (UnboundOccurrenceOf name)-  = ctoHerald <+> text "an undeclared identifier" <+> quotes (ppr name)--pprCtOrigin (DerivOriginDC dc n _)-  = hang (ctoHerald <+> text "the" <+> speakNth n-          <+> text "field of" <+> quotes (ppr dc))-       2 (parens (text "type" <+> quotes (ppr ty)))-  where-    ty = dataConOrigArgTys dc !! (n-1)--pprCtOrigin (DerivOriginCoerce meth ty1 ty2 _)-  = hang (ctoHerald <+> text "the coercion of the method" <+> quotes (ppr meth))-       2 (sep [ text "from type" <+> quotes (ppr ty1)-              , nest 2 $ text "to type" <+> quotes (ppr ty2) ])--pprCtOrigin (DoPatOrigin pat)-    = ctoHerald <+> text "a do statement"-      $$-      text "with the failable pattern" <+> quotes (ppr pat)--pprCtOrigin (MCompPatOrigin pat)-    = ctoHerald <+> hsep [ text "the failable pattern"-           , quotes (ppr pat)-           , text "in a statement in a monad comprehension" ]--pprCtOrigin (Shouldn'tHappenOrigin note)-  = 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")-       2 (text "the signature of" <+> quotes (ppr name))--pprCtOrigin (InstProvidedOrigin mod cls_inst)-  = vcat [ text "arising when attempting to show that"-         , ppr cls_inst-         , text "is provided by" <+> quotes (ppr mod)]--pprCtOrigin simple_origin-  = ctoHerald <+> pprCtO simple_origin---- | Short one-liners-pprCtO :: CtOrigin -> SDoc-pprCtO (OccurrenceOf name)   = hsep [text "a use of", quotes (ppr name)]-pprCtO (OccurrenceOfRecSel name) = hsep [text "a use of", quotes (ppr name)]-pprCtO AppOrigin             = text "an application"-pprCtO (IPOccOrigin name)    = hsep [text "a use of implicit parameter", quotes (ppr name)]-pprCtO (OverLabelOrigin l)   = hsep [text "the overloaded label"-                                    ,quotes (char '#' <> ppr l)]-pprCtO RecordUpdOrigin       = text "a record update"-pprCtO ExprSigOrigin         = text "an expression type signature"-pprCtO PatSigOrigin          = text "a pattern type signature"-pprCtO PatOrigin             = text "a pattern"-pprCtO ViewPatOrigin         = text "a view pattern"-pprCtO IfOrigin              = text "an if expression"-pprCtO (LiteralOrigin lit)   = hsep [text "the literal", quotes (ppr lit)]-pprCtO (ArithSeqOrigin seq)  = hsep [text "the arithmetic sequence", quotes (ppr seq)]-pprCtO SectionOrigin         = text "an operator section"-pprCtO AssocFamPatOrigin     = text "the LHS of a family instance"-pprCtO TupleOrigin           = text "a tuple"-pprCtO NegateOrigin          = text "a use of syntactic negation"-pprCtO (ScOrigin n)          = text "the superclasses of an instance declaration"-                               <> whenPprDebug (parens (ppr n))-pprCtO DerivClauseOrigin     = text "the 'deriving' clause of a data type declaration"-pprCtO StandAloneDerivOrigin = text "a 'deriving' declaration"-pprCtO DefaultOrigin         = text "a 'default' declaration"-pprCtO DoOrigin              = text "a do statement"-pprCtO MCompOrigin           = text "a statement in a monad comprehension"-pprCtO ProcOrigin            = text "a proc expression"-pprCtO (TypeEqOrigin t1 t2 _ _)= text "a type equality" <+> sep [ppr t1, char '~', ppr t2]-pprCtO AnnOrigin             = text "an annotation"-pprCtO HoleOrigin            = text "a use of" <+> quotes (text "_")-pprCtO ListOrigin            = text "an overloaded list"-pprCtO StaticOrigin          = text "a static form"-pprCtO BracketOrigin         = text "a quotation bracket"-pprCtO _                     = panic "pprCtOrigin"
− compiler/typecheck/TcRnTypes.hs 
@@ -1,1728 +0,0 @@-{--(c) The University of Glasgow 2006-2012-(c) The GRASP Project, Glasgow University, 1992-2002---Various types used during typechecking, please see TcRnMonad as well for-operations on these types. You probably want to import it, instead of this-module.--All the monads exported here are built on top of the same IOEnv monad. The-monad functions like a Reader monad in the way it passes the environment-around. This is done to allow the environment to be manipulated in a stack-like fashion when entering expressions... etc.--For state that is global and should be returned at the end (e.g not part-of the stack mechanism), you should use a TcRef (= IORef) to store them.--}--{-# LANGUAGE CPP, DeriveFunctor, ExistentialQuantification, GeneralizedNewtypeDeriving,-             ViewPatterns #-}--module TcRnTypes(-        TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module-        TcRef,--        -- The environment types-        Env(..),-        TcGblEnv(..), TcLclEnv(..),-        setLclEnvTcLevel, getLclEnvTcLevel,-        setLclEnvLoc, getLclEnvLoc,-        IfGblEnv(..), IfLclEnv(..),-        tcVisibleOrphanMods,--        -- Frontend types (shouldn't really be here)-        FrontendResult(..),--        -- Renamer types-        ErrCtxt, RecFieldEnv, pushErrCtxt, pushErrCtxtSameOrigin,-        ImportAvails(..), emptyImportAvails, plusImportAvails,-        WhereFrom(..), mkModDeps, modDepsElts,--        -- Typechecker types-        TcTypeEnv, TcBinderStack, TcBinder(..),-        TcTyThing(..), PromotionErr(..),-        IdBindingInfo(..), ClosedTypeId, RhsNames,-        IsGroupClosed(..),-        SelfBootInfo(..),-        pprTcTyThingCategory, pprPECategory, CompleteMatch(..),--        -- Desugaring types-        DsM, DsLclEnv(..), DsGblEnv(..),-        DsMetaEnv, DsMetaVal(..), CompleteMatchMap,-        mkCompleteMatchMap, extendCompleteMatchMap,--        -- Template Haskell-        ThStage(..), SpliceType(..), PendingStuff(..),-        topStage, topAnnStage, topSpliceStage,-        ThLevel, impLevel, outerLevel, thLevel,-        ForeignSrcLang(..),--        -- Arrows-        ArrowCtxt(..),--        -- TcSigInfo-        TcSigFun, TcSigInfo(..), TcIdSigInfo(..),-        TcIdSigInst(..), TcPatSynInfo(..),-        isPartialSig, hasCompleteSig,--        -- Misc other types-        TcId, TcIdSet,-        NameShape(..),-        removeBindingShadowing,--        -- Constraint solver plugins-        TcPlugin(..), TcPluginResult(..), TcPluginSolver,-        TcPluginM, runTcPluginM, unsafeTcPluginTcM,-        getEvBindsTcPluginM,--        -- Role annotations-        RoleAnnotEnv, emptyRoleAnnotEnv, mkRoleAnnotEnv,-        lookupRoleAnnot, getRoleAnnots-  ) where--#include "HsVersions.h"--import GhcPrelude--import GHC.Hs-import GHC.Driver.Types-import TcEvidence-import GHC.Core.Type-import GHC.Core.TyCon  ( TyCon, tyConKind )-import GHC.Core.PatSyn ( PatSyn )-import GHC.Types.Id         ( idType, idName )-import GHC.Types.FieldLabel ( FieldLabel )-import TcType-import Constraint-import TcOrigin-import GHC.Types.Annotations-import GHC.Core.InstEnv-import GHC.Core.FamInstEnv-import {-# SOURCE #-} GHC.HsToCore.PmCheck.Types (Deltas)-import IOEnv-import GHC.Types.Name.Reader-import GHC.Types.Name-import GHC.Types.Name.Env-import GHC.Types.Name.Set-import GHC.Types.Avail-import GHC.Types.Var-import GHC.Types.Var.Env-import GHC.Types.Module-import GHC.Types.SrcLoc-import GHC.Types.Var.Set-import ErrUtils-import GHC.Types.Unique.FM-import GHC.Types.Basic-import Bag-import GHC.Driver.Session-import Outputable-import ListSetOps-import Fingerprint-import Util-import PrelNames ( isUnboundName )-import GHC.Types.CostCentre.State--import Control.Monad (ap)-import Data.Set      ( Set )-import qualified Data.Set as S--import Data.List ( sort )-import Data.Map ( Map )-import Data.Dynamic  ( Dynamic )-import Data.Typeable ( TypeRep )-import Data.Maybe    ( mapMaybe )-import GHCi.Message-import GHCi.RemoteTypes--import {-# SOURCE #-} TcHoleFitTypes ( HoleFitPlugin )--import qualified Language.Haskell.TH as TH---- | A 'NameShape' is a substitution on 'Name's that can be used--- to refine the identities of a hole while we are renaming interfaces--- (see 'GHC.Iface.Rename').  Specifically, a 'NameShape' for--- 'ns_module_name' @A@, defines a mapping from @{A.T}@--- (for some 'OccName' @T@) to some arbitrary other 'Name'.------ The most intruiging thing about a 'NameShape', however, is--- how it's constructed.  A 'NameShape' is *implied* by the--- exported 'AvailInfo's of the implementor of an interface:--- if an implementor of signature @<H>@ exports @M.T@, you implicitly--- define a substitution from @{H.T}@ to @M.T@.  So a 'NameShape'--- is computed from the list of 'AvailInfo's that are exported--- by the implementation of a module, or successively merged--- together by the export lists of signatures which are joining--- together.------ It's not the most obvious way to go about doing this, but it--- does seem to work!------ NB: Can't boot this and put it in NameShape because then we--- start pulling in too many DynFlags things.-data NameShape = NameShape {-        ns_mod_name :: ModuleName,-        ns_exports :: [AvailInfo],-        ns_map :: OccEnv Name-    }---{--************************************************************************-*                                                                      *-               Standard monad definition for TcRn-    All the combinators for the monad can be found in TcRnMonad-*                                                                      *-************************************************************************--The monad itself has to be defined here, because it is mentioned by ErrCtxt--}--type TcRnIf a b = IOEnv (Env a b)-type TcRn       = TcRnIf TcGblEnv TcLclEnv    -- Type inference-type IfM lcl    = TcRnIf IfGblEnv lcl         -- Iface stuff-type IfG        = IfM ()                      --    Top level-type IfL        = IfM IfLclEnv                --    Nested-type DsM        = TcRnIf DsGblEnv DsLclEnv    -- Desugaring---- TcRn is the type-checking and renaming monad: the main monad that--- most type-checking takes place in.  The global environment is--- 'TcGblEnv', which tracks all of the top-level type-checking--- information we've accumulated while checking a module, while the--- local environment is 'TcLclEnv', which tracks local information as--- we move inside expressions.---- | Historical "renaming monad" (now it's just 'TcRn').-type RnM  = TcRn---- | Historical "type-checking monad" (now it's just 'TcRn').-type TcM  = TcRn---- We 'stack' these envs through the Reader like monad infrastructure--- as we move into an expression (although the change is focused in--- the lcl type).-data Env gbl lcl-  = Env {-        env_top  :: !HscEnv, -- Top-level stuff that never changes-                             -- Includes all info about imported things-                             -- BangPattern is to fix leak, see #15111--        env_um   :: !Char,   -- Mask for Uniques--        env_gbl  :: gbl,     -- Info about things defined at the top level-                             -- of the module being compiled--        env_lcl  :: lcl      -- Nested stuff; changes as we go into-    }--instance ContainsDynFlags (Env gbl lcl) where-    extractDynFlags env = hsc_dflags (env_top env)--instance ContainsModule gbl => ContainsModule (Env gbl lcl) where-    extractModule env = extractModule (env_gbl env)---{--************************************************************************-*                                                                      *-                The interface environments-              Used when dealing with IfaceDecls-*                                                                      *-************************************************************************--}--data IfGblEnv-  = IfGblEnv {-        -- Some information about where this environment came from;-        -- useful for debugging.-        if_doc :: SDoc,-        -- The type environment for the module being compiled,-        -- in case the interface refers back to it via a reference that-        -- was originally a hi-boot file.-        -- We need the module name so we can test when it's appropriate-        -- to look in this env.-        -- See Note [Tying the knot] in GHC.IfaceToCore-        if_rec_types :: Maybe (Module, IfG TypeEnv)-                -- Allows a read effect, so it can be in a mutable-                -- variable; c.f. handling the external package type env-                -- Nothing => interactive stuff, no loops possible-    }--data IfLclEnv-  = IfLclEnv {-        -- The module for the current IfaceDecl-        -- So if we see   f = \x -> x-        -- it means M.f = \x -> x, where M is the if_mod-        -- NB: This is a semantic module, see-        -- Note [Identity versus semantic module]-        if_mod :: Module,--        -- Whether or not the IfaceDecl came from a boot-        -- file or not; we'll use this to choose between-        -- NoUnfolding and BootUnfolding-        if_boot :: Bool,--        -- The field is used only for error reporting-        -- if (say) there's a Lint error in it-        if_loc :: SDoc,-                -- Where the interface came from:-                --      .hi file, or GHCi state, or ext core-                -- plus which bit is currently being examined--        if_nsubst :: Maybe NameShape,--        -- This field is used to make sure "implicit" declarations-        -- (anything that cannot be exported in mi_exports) get-        -- wired up correctly in typecheckIfacesForMerging.  Most-        -- of the time it's @Nothing@.  See Note [Resolving never-exported Names]-        -- in GHC.IfaceToCore.-        if_implicits_env :: Maybe TypeEnv,--        if_tv_env  :: FastStringEnv TyVar,     -- Nested tyvar bindings-        if_id_env  :: FastStringEnv Id         -- Nested id binding-    }--{--************************************************************************-*                                                                      *-                Desugarer monad-*                                                                      *-************************************************************************--Now the mondo monad magic (yes, @DsM@ is a silly name)---carry around-a @UniqueSupply@ and some annotations, which-presumably include source-file location information:--}--data DsGblEnv-        = DsGblEnv-        { ds_mod          :: Module             -- For SCC profiling-        , ds_fam_inst_env :: FamInstEnv         -- Like tcg_fam_inst_env-        , ds_unqual  :: PrintUnqualified-        , ds_msgs    :: IORef Messages          -- Warning messages-        , ds_if_env  :: (IfGblEnv, IfLclEnv)    -- Used for looking up global,-                                                -- possibly-imported things-        , ds_complete_matches :: CompleteMatchMap-           -- Additional complete pattern matches-        , ds_cc_st   :: IORef CostCentreState-           -- Tracking indices for cost centre annotations-        }--instance ContainsModule DsGblEnv where-    extractModule = ds_mod--data DsLclEnv = DsLclEnv {-        dsl_meta    :: DsMetaEnv,        -- Template Haskell bindings-        dsl_loc     :: RealSrcSpan,      -- To put in pattern-matching error msgs--        -- See Note [Note [Type and Term Equality Propagation] in Check.hs-        -- 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--- up variables in the DsMetaEnv-type DsMetaEnv = NameEnv DsMetaVal--data DsMetaVal-   = DsBound Id         -- Bound by a pattern inside the [| |].-                        -- Will be dynamically alpha renamed.-                        -- The Id has type THSyntax.Var--   | DsSplice (HsExpr GhcTc) -- These bindings are introduced by-                             -- the PendingSplices on a HsBracketOut---{--************************************************************************-*                                                                      *-                Global typechecker environment-*                                                                      *-************************************************************************--}---- | '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 GHC.Driver.Types, but it needs--- to have a TcGblEnv which is only defined here.-data FrontendResult-        = FrontendTypecheck TcGblEnv---- Note [Identity versus semantic module]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--- When typechecking an hsig file, it is convenient to keep track--- of two different "this module" identifiers:------      - The IDENTITY module is simply thisPackage + the module---        name; i.e. it uniquely *identifies* the interface file---        we're compiling.  For example, p[A=<A>]:A is an---        identity module identifying the requirement named A---        from library p.------      - The SEMANTIC module, which is the actual module that---        this signature is intended to represent (e.g. if---        we have a identity module p[A=base:Data.IORef]:A,---        then the semantic module is base:Data.IORef)------ Which one should you use?------      - In the desugarer and later phases of compilation,---        identity and semantic modules coincide, since we never compile---        signatures (we just generate blank object files for---        hsig files.)------        A corrolary of this is that the following invariant holds at any point---        past desugaring,------            if I have a Module, this_mod, in hand representing the module---            currently being compiled,---            then moduleUnitId this_mod == thisPackage dflags------      - For any code involving Names, we want semantic modules.---        See lookupIfaceTop in GHC.Iface.Env, mkIface and addFingerprints---        in GHC.Iface.{Make,Recomp}, and tcLookupGlobal in TcEnv------      - When reading interfaces, we want the identity module to---        identify the specific interface we want (such interfaces---        should never be loaded into the EPS).  However, if a---        hole module <A> is requested, we look for A.hi---        in the home library we are compiling.  (See GHC.Iface.Load.)---        Similarly, in GHC.Rename.Names we check for self-imports using---        identity modules, to allow signatures to import their implementor.------      - For recompilation avoidance, you want the identity module,---        since that will actually say the specific interface you---        want to track (and recompile if it changes)---- | 'TcGblEnv' describes the top-level of the module at the--- point at which the typechecker is finished work.--- It is this structure that is handed on to the desugarer--- For state that needs to be updated during the typechecking--- phase and returned at end, use a 'TcRef' (= 'IORef').-data TcGblEnv-  = TcGblEnv {-        tcg_mod     :: Module,         -- ^ Module being compiled-        tcg_semantic_mod :: Module,    -- ^ If a signature, the backing module-            -- See also Note [Identity versus semantic module]-        tcg_src     :: HscSource,-          -- ^ What kind of module (regular Haskell, hs-boot, hsig)--        tcg_rdr_env :: GlobalRdrEnv,   -- ^ Top level envt; used during renaming-        tcg_default :: Maybe [Type],-          -- ^ Types used for defaulting. @Nothing@ => no @default@ decl--        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 GHC.Driver.Types--        tcg_type_env :: TypeEnv,-          -- ^ Global type env for the module we are compiling now.  All-          -- TyCons and Classes (for this module) end up in here right away,-          -- along with their derived constructors, selectors.-          ---          -- (Ids defined in this module start in the local envt, though they-          --  move to the global envt during zonking)-          ---          -- NB: for what "things in this module" means, see-          -- Note [The interactive package] in GHC.Driver.Types--        tcg_type_env_var :: TcRef TypeEnv,-                -- Used only to initialise the interface-file-                -- typechecker in initIfaceTcRn, so that it can see stuff-                -- bound in this module when dealing with hi-boot recursions-                -- Updated at intervals (e.g. after dealing with types and classes)--        tcg_inst_env     :: !InstEnv,-          -- ^ Instance envt for all /home-package/ modules;-          -- Includes the dfuns in tcg_insts-          -- NB. BangPattern is to fix a leak, see #15111-        tcg_fam_inst_env :: !FamInstEnv, -- ^ Ditto for family instances-          -- NB. BangPattern is to fix a leak, see #15111-        tcg_ann_env      :: AnnEnv,     -- ^ And for annotations--                -- Now a bunch of things about this module that are simply-                -- accumulated, but never consulted until the end.-                -- Nevertheless, it's convenient to accumulate them along-                -- with the rest of the info from this module.-        tcg_exports :: [AvailInfo],     -- ^ What is exported-        tcg_imports :: ImportAvails,-          -- ^ Information about what was imported from where, including-          -- things bound in this module. Also store Safe Haskell info-          -- here about transitive trusted package requirements.-          ---          -- There are not many uses of this field, so you can grep for-          -- all them.-          ---          -- The ImportAvails records information about the following-          -- things:-          ---          --    1. All of the modules you directly imported (tcRnImports)-          --    2. The orphans (only!) of all imported modules in a GHCi-          --       session (runTcInteractive)-          --    3. The module that instantiated a signature-          --    4. Each of the signatures that merged in-          ---          -- It is used in the following ways:-          --    - imp_orphs is used to determine what orphan modules should be-          --      visible in the context (tcVisibleOrphanMods)-          --    - imp_finsts is used to determine what family instances should-          --      be visible (tcExtendLocalFamInstEnv)-          --    - To resolve the meaning of the export list of a module-          --      (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 GHC.Driver.Main)-          --    - To create the Dependencies field in interface (mkDependencies)--          -- These three fields track unused bindings and imports-          -- See Note [Tracking unused binding and imports]-        tcg_dus       :: DefUses,-        tcg_used_gres :: TcRef [GlobalRdrElt],-        tcg_keep      :: TcRef NameSet,--        tcg_th_used :: TcRef Bool,-          -- ^ @True@ <=> Template Haskell syntax used.-          ---          -- We need this so that we can generate a dependency on the-          -- Template Haskell package, because the desugarer is going-          -- to emit loads of references to TH symbols.  The reference-          -- is implicit rather than explicit, so we have to zap a-          -- mutable variable.--        tcg_th_splice_used :: TcRef Bool,-          -- ^ @True@ <=> A Template Haskell splice was used.-          ---          -- Splices disable recompilation avoidance (see #481)--        tcg_dfun_n  :: TcRef OccSet,-          -- ^ Allows us to choose unique DFun names.--        tcg_merged :: [(Module, Fingerprint)],-          -- ^ The requirements we merged with; we always have to recompile-          -- if any of these changed.--        -- The next fields accumulate the payload of the module-        -- The binds, rules and foreign-decl fields are collected-        -- initially in un-zonked form and are finally zonked in tcRnSrcDecls--        tcg_rn_exports :: Maybe [(Located (IE GhcRn), Avails)],-                -- Nothing <=> no explicit export list-                -- Is always Nothing if we don't want to retain renamed-                -- exports.-                -- If present contains each renamed export list item-                -- together with its exported names.--        tcg_rn_imports :: [LImportDecl GhcRn],-                -- Keep the renamed imports regardless.  They are not-                -- voluminous and are needed if you want to report unused imports--        tcg_rn_decls :: Maybe (HsGroup GhcRn),-          -- ^ Renamed decls, maybe.  @Nothing@ <=> Don't retain renamed-          -- decls.--        tcg_dependent_files :: TcRef [FilePath], -- ^ dependencies from addDependentFile--        tcg_th_topdecls :: TcRef [LHsDecl GhcPs],-        -- ^ Top-level declarations from addTopDecls--        tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)],-        -- ^ Foreign files emitted from TH.--        tcg_th_topnames :: TcRef NameSet,-        -- ^ Exact names bound in top-level declarations in tcg_th_topdecls--        tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)],-        -- ^ Template Haskell module finalizers.-        ---        -- They can use particular local environments.--        tcg_th_coreplugins :: TcRef [String],-        -- ^ Core plugins added by Template Haskell code.--        tcg_th_state :: TcRef (Map TypeRep Dynamic),-        tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState))),-        -- ^ Template Haskell state--        tcg_ev_binds  :: Bag EvBind,        -- Top-level evidence bindings--        -- 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 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-        tcg_binds     :: LHsBinds GhcTc,     -- Value bindings in this module-        tcg_sigs      :: NameSet,            -- ...Top-level names that *lack* a signature-        tcg_imp_specs :: [LTcSpecPrag],      -- ...SPECIALISE prags for imported Ids-        tcg_warns     :: Warnings,           -- ...Warnings and deprecations-        tcg_anns      :: [Annotation],       -- ...Annotations-        tcg_tcs       :: [TyCon],            -- ...TyCons and Classes-        tcg_insts     :: [ClsInst],          -- ...Instances-        tcg_fam_insts :: [FamInst],          -- ...Family instances-        tcg_rules     :: [LRuleDecl GhcTc],  -- ...Rules-        tcg_fords     :: [LForeignDecl GhcTc], -- ...Foreign import & exports-        tcg_patsyns   :: [PatSyn],            -- ...Pattern synonyms--        tcg_doc_hdr   :: Maybe LHsDocString, -- ^ Maybe Haddock header docs-        tcg_hpc       :: !AnyHpcUsage,       -- ^ @True@ if any part of the-                                             --  prog uses hpc instrumentation.-           -- NB. BangPattern is to fix a leak, see #15111--        tcg_self_boot :: SelfBootInfo,       -- ^ Whether this module has a-                                             -- corresponding hi-boot file--        tcg_main      :: Maybe Name,         -- ^ The Name of the main-                                             -- function, if this module is-                                             -- the main module.--        tcg_safeInfer :: TcRef (Bool, WarningMessages),-        -- ^ Has the typechecker inferred this module as -XSafe (Safe Haskell)-        -- See Note [Safe Haskell Overlapping Instances Implementation],-        -- although this is used for more than just that failure case.--        tcg_tc_plugins :: [TcPluginSolver],-        -- ^ A list of user-defined plugins for the constraint solver.-        tcg_hf_plugins :: [HoleFitPlugin],-        -- ^ A list of user-defined plugins for hole fit suggestions.--        tcg_top_loc :: RealSrcSpan,-        -- ^ The RealSrcSpan this module came from--        tcg_static_wc :: TcRef WantedConstraints,-          -- ^ Wanted constraints of static forms.-        -- See Note [Constraints in static forms].-        tcg_complete_matches :: [CompleteMatch],--        -- ^ Tracking indices for cost centre annotations-        tcg_cc_st   :: TcRef CostCentreState-    }---- NB: topModIdentity, not topModSemantic!--- Definition sites of orphan identities will be identity modules, not semantic--- modules.---- Note [Constraints in static forms]--- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~------ When a static form produces constraints like------ f :: StaticPtr (Bool -> String)--- f = static show------ we collect them in tcg_static_wc and resolve them at the end--- of type checking. They need to be resolved separately because--- we don't want to resolve them in the context of the enclosing--- expression. Consider------ g :: Show a => StaticPtr (a -> String)--- g = static show------ If the @Show a0@ constraint that the body of the static form produces was--- resolved in the context of the enclosing expression, then the body of the--- static form wouldn't be closed because the Show dictionary would come from--- g's context instead of coming from the top level.--tcVisibleOrphanMods :: TcGblEnv -> ModuleSet-tcVisibleOrphanMods tcg_env-    = mkModuleSet (tcg_mod tcg_env : imp_orphs (tcg_imports tcg_env))--instance ContainsModule TcGblEnv where-    extractModule env = tcg_semantic_mod env--type RecFieldEnv = NameEnv [FieldLabel]-        -- Maps a constructor name *in this module*-        -- to the fields for that constructor.-        -- This is used when dealing with ".." notation in record-        -- construction and pattern matching.-        -- The FieldEnv deals *only* with constructors defined in *this*-        -- module.  For imported modules, we get the same info from the-        -- TypeEnv--data SelfBootInfo-  = NoSelfBoot    -- No corresponding hi-boot file-  | SelfBoot-       { sb_mds :: ModDetails   -- There was a hi-boot file,-       , sb_tcs :: NameSet }    -- defining these TyCons,--- What is sb_tcs used for?  See Note [Extra dependencies from .hs-boot files]--- in GHC.Rename.Source---{- Note [Tracking unused binding and imports]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We gather three sorts of usage information-- * tcg_dus :: DefUses (defs/uses)-      Records what is defined in this module and what is used.--      Records *defined* Names (local, top-level)-          and *used*    Names (local or imported)--      Used (a) to report "defined but not used"-               (see GHC.Rename.Names.reportUnusedNames)-           (b) to generate version-tracking usage info in interface-               files (see GHC.Iface.Make.mkUsedNames)-   This usage info is mainly gathered by the renamer's-   gathering of free-variables-- * tcg_used_gres :: TcRef [GlobalRdrElt]-      Records occurrences of imported entities.--      Used only to report unused import declarations--      Records each *occurrence* an *imported* (not locally-defined) entity.-      The occurrence is recorded by keeping a GlobalRdrElt for it.-      These is not the GRE that is in the GlobalRdrEnv; rather it-      is recorded *after* the filtering done by pickGREs.  So it reflect-      /how that occurrence is in scope/.   See Note [GRE filtering] in-      RdrName.--  * tcg_keep :: TcRef NameSet-      Records names of the type constructors, data constructors, and Ids that-      are used by the constraint solver.--      The typechecker may use find that some imported or-      locally-defined things are used, even though they-      do not appear to be mentioned in the source code:--      (a) The to/from functions for generic data types--      (b) Top-level variables appearing free in the RHS of an-          orphan rule--      (c) Top-level variables appearing free in a TH bracket-          See Note [Keeping things alive for Template Haskell]-          in GHC.Rename.Splice--      (d) The data constructor of a newtype that is used-          to solve a Coercible instance (e.g. #10347). Example-              module T10347 (N, mkN) where-                import Data.Coerce-                newtype N a = MkN Int-                mkN :: Int -> N a-                mkN = coerce--          Then we wish to record `MkN` as used, since it is (morally)-          used to perform the coercion in `mkN`. To do so, the-          Coercible solver updates tcg_keep's TcRef whenever it-          encounters a use of `coerce` that crosses newtype boundaries.--      The tcg_keep field is used in two distinct ways:--      * Desugar.addExportFlagsAndRules.  Where things like (a-c) are locally-        defined, we should give them an an Exported flag, so that the-        simplifier does not discard them as dead code, and so that they are-        exposed in the interface file (but not to export to the user).--      * GHC.Rename.Names.reportUnusedNames.  Where newtype data constructors-        like (d) are imported, we don't want to report them as unused.---************************************************************************-*                                                                      *-                The local typechecker environment-*                                                                      *-************************************************************************--Note [The Global-Env/Local-Env story]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-During type checking, we keep in the tcg_type_env-        * All types and classes-        * All Ids derived from types and classes (constructors, selectors)--At the end of type checking, we zonk the local bindings,-and as we do so we add to the tcg_type_env-        * Locally defined top-level Ids--Why?  Because they are now Ids not TcIds.  This final GlobalEnv is-        a) fed back (via the knot) to typechecking the-           unfoldings of interface signatures-        b) used in the ModDetails of this module--}--data TcLclEnv           -- Changes as we move inside an expression-                        -- Discarded after typecheck/rename; not passed on to desugarer-  = TcLclEnv {-        tcl_loc        :: RealSrcSpan,     -- Source span-        tcl_ctxt       :: [ErrCtxt],       -- Error context, innermost on top-        tcl_tclvl      :: TcLevel,         -- Birthplace for new unification variables--        tcl_th_ctxt    :: ThStage,         -- Template Haskell context-        tcl_th_bndrs   :: ThBindEnv,       -- and binder info-            -- The ThBindEnv records the TH binding level of in-scope Names-            -- defined in this module (not imported)-            -- We can't put this info in the TypeEnv because it's needed-            -- (and extended) in the renamer, for untyed splices--        tcl_arrow_ctxt :: ArrowCtxt,       -- Arrow-notation context--        tcl_rdr :: LocalRdrEnv,         -- Local name envt-                -- Maintained during renaming, of course, but also during-                -- type checking, solely so that when renaming a Template-Haskell-                -- splice we have the right environment for the renamer.-                ---                --   Does *not* include global name envt; may shadow it-                --   Includes both ordinary variables and type variables;-                --   they are kept distinct because tyvar have a different-                --   occurrence constructor (Name.TvOcc)-                -- We still need the unsullied global name env so that-                --   we can look up record field names--        tcl_env  :: TcTypeEnv,    -- The local type environment:-                                  -- Ids and TyVars defined in this module--        tcl_bndrs :: TcBinderStack,   -- Used for reporting relevant bindings,-                                      -- and for tidying types--        tcl_lie  :: TcRef WantedConstraints,    -- Place to accumulate type constraints-        tcl_errs :: TcRef Messages              -- Place to accumulate errors-    }--setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv-setLclEnvTcLevel env lvl = env { tcl_tclvl = lvl }--getLclEnvTcLevel :: TcLclEnv -> TcLevel-getLclEnvTcLevel = tcl_tclvl--setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv-setLclEnvLoc env loc = env { tcl_loc = loc }--getLclEnvLoc :: TcLclEnv -> RealSrcSpan-getLclEnvLoc = tcl_loc--type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))-        -- Monadic so that we have a chance-        -- to deal with bound type variables just before error-        -- message construction--        -- Bool:  True <=> this is a landmark context; do not-        --                 discard it when trimming for display---- These are here to avoid module loops: one might expect them--- in Constraint, but they refer to ErrCtxt which refers to TcM.--- Easier to just keep these definitions here, alongside TcM.-pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc-pushErrCtxt o err loc@(CtLoc { ctl_env = lcl })-  = loc { ctl_origin = o, ctl_env = lcl { tcl_ctxt = err : tcl_ctxt lcl } }--pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc--- Just add information w/o updating the origin!-pushErrCtxtSameOrigin err loc@(CtLoc { ctl_env = lcl })-  = loc { ctl_env = lcl { tcl_ctxt = err : tcl_ctxt lcl } }--type TcTypeEnv = NameEnv TcTyThing--type ThBindEnv = NameEnv (TopLevelFlag, ThLevel)-   -- Domain = all Ids bound in this module (ie not imported)-   -- The TopLevelFlag tells if the binding is syntactically top level.-   -- We need to know this, because the cross-stage persistence story allows-   -- cross-stage at arbitrary types if the Id is bound at top level.-   ---   -- Nota bene: a ThLevel of 'outerLevel' is *not* the same as being-   -- bound at top level!  See Note [Template Haskell levels] in TcSplice--{- Note [Given Insts]-   ~~~~~~~~~~~~~~~~~~-Because of GADTs, we have to pass inwards the Insts provided by type signatures-and existential contexts. Consider-        data T a where { T1 :: b -> b -> T [b] }-        f :: Eq a => T a -> Bool-        f (T1 x y) = [x]==[y]--The constructor T1 binds an existential variable 'b', and we need Eq [b].-Well, we have it, because Eq a refines to Eq [b], but we can only spot that if we-pass it inwards.---}---- | Type alias for 'IORef'; the convention is we'll use this for mutable--- bits of data in 'TcGblEnv' which are updated during typechecking and--- returned at the end.-type TcRef a     = IORef a--- ToDo: when should I refer to it as a 'TcId' instead of an 'Id'?-type TcId        = Id-type TcIdSet     = IdSet-------------------------------- The TcBinderStack------------------------------type TcBinderStack = [TcBinder]-   -- This is a stack of locally-bound ids and tyvars,-   --   innermost on top-   -- Used only in error reporting (relevantBindings in TcError),-   --   and in tidying-   -- We can't use the tcl_env type environment, because it doesn't-   --   keep track of the nesting order--data TcBinder-  = TcIdBndr-       TcId-       TopLevelFlag    -- Tells whether the binding is syntactically top-level-                       -- (The monomorphic Ids for a recursive group count-                       --  as not-top-level for this purpose.)--  | TcIdBndr_ExpType  -- Variant that allows the type to be specified as-                      -- an ExpType-       Name-       ExpType-       TopLevelFlag--  | TcTvBndr          -- e.g.   case x of P (y::a) -> blah-       Name           -- We bind the lexical name "a" to the type of y,-       TyVar          -- which might be an utterly different (perhaps-                      -- existential) tyvar--instance Outputable TcBinder where-   ppr (TcIdBndr id top_lvl)           = ppr id <> brackets (ppr top_lvl)-   ppr (TcIdBndr_ExpType id _ top_lvl) = ppr id <> brackets (ppr top_lvl)-   ppr (TcTvBndr name tv)              = ppr name <+> ppr tv--instance HasOccName TcBinder where-    occName (TcIdBndr id _)             = occName (idName id)-    occName (TcIdBndr_ExpType name _ _) = occName name-    occName (TcTvBndr name _)           = occName name---- fixes #12177--- Builds up a list of bindings whose OccName has not been seen before--- i.e., If    ys  = removeBindingShadowing xs--- then---  - ys is obtained from xs by deleting some elements---  - ys has no duplicate OccNames---  - The first duplicated OccName in xs is retained in ys--- Overloaded so that it can be used for both GlobalRdrElt in typed-hole--- substitutions and TcBinder when looking for relevant bindings.-removeBindingShadowing :: HasOccName a => [a] -> [a]-removeBindingShadowing bindings = reverse $ fst $ foldl-    (\(bindingAcc, seenNames) binding ->-    if occName binding `elemOccSet` seenNames -- if we've seen it-        then (bindingAcc, seenNames)              -- skip it-        else (binding:bindingAcc, extendOccSet seenNames (occName binding)))-    ([], emptyOccSet) bindings-------------------------------- Template Haskell stages and levels------------------------------data SpliceType = Typed | Untyped--data ThStage    -- See Note [Template Haskell state diagram]-                -- and Note [Template Haskell levels] in TcSplice-    -- Start at:   Comp-    -- At bracket: wrap current stage in Brack-    -- At splice:  currently Brack: return to previous stage-    --             currently Comp/Splice: compile and run-  = Splice SpliceType -- Inside a top-level splice-                      -- This code will be run *at compile time*;-                      --   the result replaces the splice-                      -- Binding level = 0--  | RunSplice (TcRef [ForeignRef (TH.Q ())])-      -- Set when running a splice, i.e. NOT when renaming or typechecking the-      -- Haskell code for the splice. See Note [RunSplice ThLevel].-      ---      -- Contains a list of mod finalizers collected while executing the splice.-      ---      -- 'addModFinalizer' inserts finalizers here, and from here they are taken-      -- to construct an @HsSpliced@ annotation for untyped splices. See Note-      -- [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice.-      ---      -- For typed splices, the typechecker takes finalizers from here and-      -- inserts them in the list of finalizers in the global environment.-      ---      -- See Note [Collecting modFinalizers in typed splices] in "TcSplice".--  | Comp        -- Ordinary Haskell code-                -- Binding level = 1--  | Brack                       -- Inside brackets-      ThStage                   --   Enclosing stage-      PendingStuff--data PendingStuff-  = RnPendingUntyped              -- Renaming the inside of an *untyped* bracket-      (TcRef [PendingRnSplice])   -- Pending splices in here--  | RnPendingTyped                -- Renaming the inside of a *typed* bracket--  | TcPending                     -- Typechecking the inside of a typed bracket-      (TcRef [PendingTcSplice])   --   Accumulate pending splices here-      (TcRef WantedConstraints)   --     and type constraints here-      QuoteWrapper                -- A type variable and evidence variable-                                  -- for the overall monad of-                                  -- the bracket. Splices are checked-                                  -- against this monad. The evidence-                                  -- variable is used for desugaring-                                  -- `lift`.---topStage, topAnnStage, topSpliceStage :: ThStage-topStage       = Comp-topAnnStage    = Splice Untyped-topSpliceStage = Splice Untyped--instance Outputable ThStage where-   ppr (Splice _)    = text "Splice"-   ppr (RunSplice _) = text "RunSplice"-   ppr Comp          = text "Comp"-   ppr (Brack s _)   = text "Brack" <> parens (ppr s)--type ThLevel = Int-    -- NB: see Note [Template Haskell levels] in TcSplice-    -- Incremented when going inside a bracket,-    -- decremented when going inside a splice-    -- NB: ThLevel is one greater than the 'n' in Fig 2 of the-    --     original "Template meta-programming for Haskell" paper--impLevel, outerLevel :: ThLevel-impLevel = 0    -- Imported things; they can be used inside a top level splice-outerLevel = 1  -- Things defined outside brackets--thLevel :: ThStage -> ThLevel-thLevel (Splice _)    = 0-thLevel Comp          = 1-thLevel (Brack s _)   = thLevel s + 1-thLevel (RunSplice _) = panic "thLevel: called when running a splice"-                        -- See Note [RunSplice ThLevel].--{- Node [RunSplice ThLevel]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The 'RunSplice' stage is set when executing a splice, and only when running a-splice. In particular it is not set when the splice is renamed or typechecked.--'RunSplice' is needed to provide a reference where 'addModFinalizer' can insert-the finalizer (see Note [Delaying modFinalizers in untyped splices]), and-'addModFinalizer' runs when doing Q things. Therefore, It doesn't make sense to-set 'RunSplice' when renaming or typechecking the splice, where 'Splice',-'Brack' or 'Comp' are used instead.---}-------------------------------- Arrow-notation context------------------------------{- Note [Escaping the arrow scope]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In arrow notation, a variable bound by a proc (or enclosed let/kappa)-is not in scope to the left of an arrow tail (-<) or the head of (|..|).-For example--        proc x -> (e1 -< e2)--Here, x is not in scope in e1, but it is in scope in e2.  This can get-a bit complicated:--        let x = 3 in-        proc y -> (proc z -> e1) -< e2--Here, x and z are in scope in e1, but y is not.--We implement this by-recording the environment when passing a proc (using newArrowScope),-and returning to that (using escapeArrowScope) on the left of -< and the-head of (|..|).--All this can be dealt with by the *renamer*. But the type checker needs-to be involved too.  Example (arrowfail001)-  class Foo a where foo :: a -> ()-  data Bar = forall a. Foo a => Bar a-  get :: Bar -> ()-  get = proc x -> case x of Bar a -> foo -< a-Here the call of 'foo' gives rise to a (Foo a) constraint that should not-be captured by the pattern match on 'Bar'.  Rather it should join the-constraints from further out.  So we must capture the constraint bag-from further out in the ArrowCtxt that we push inwards.--}--data ArrowCtxt   -- Note [Escaping the arrow scope]-  = NoArrowCtxt-  | ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)--------------------------------- TcTyThing-------------------------------- | A typecheckable thing available in a local context.  Could be--- 'AGlobal' 'TyThing', but also lexically scoped variables, etc.--- See 'TcEnv' for how to retrieve a 'TyThing' given a 'Name'.-data TcTyThing-  = AGlobal TyThing             -- Used only in the return type of a lookup--  | ATcId           -- Ids defined in this module; may not be fully zonked-      { tct_id   :: TcId-      , tct_info :: IdBindingInfo   -- See Note [Meaning of IdBindingInfo]-      }--  | ATyVar  Name TcTyVar   -- See Note [Type variables in the type environment]--  | ATcTyCon TyCon   -- Used temporarily, during kind checking, for the-                     -- tycons and clases in this recursive group-                     -- The TyCon is always a TcTyCon.  Its kind-                     -- can be a mono-kind or a poly-kind; in TcTyClsDcls see-                     -- Note [Type checking recursive type and class declarations]--  | APromotionErr PromotionErr--data PromotionErr-  = TyConPE          -- TyCon used in a kind before we are ready-                     --     data T :: T -> * where ...-  | ClassPE          -- Ditto Class--  | FamDataConPE     -- Data constructor for a data family-                     -- See Note [AFamDataCon: not promoting data family constructors]-                     -- in TcEnv.-  | ConstrainedDataConPE PredType-                     -- Data constructor with a non-equality context-                     -- See Note [Don't promote data constructors with-                     --           non-equality contexts] in TcHsType-  | PatSynPE         -- Pattern synonyms-                     -- See Note [Don't promote pattern synonyms] in TcEnv--  | RecDataConPE     -- Data constructor in a recursive loop-                     -- See Note [Recursion and promoting data constructors] in TcTyClsDecls-  | NoDataKindsTC    -- -XDataKinds not enabled (for a tycon)-  | NoDataKindsDC    -- -XDataKinds not enabled (for a datacon)--instance Outputable TcTyThing where     -- Debugging only-   ppr (AGlobal g)      = ppr g-   ppr elt@(ATcId {})   = text "Identifier" <>-                          brackets (ppr (tct_id elt) <> dcolon-                                 <> ppr (varType (tct_id elt)) <> comma-                                 <+> ppr (tct_info elt))-   ppr (ATyVar n tv)    = text "Type variable" <+> quotes (ppr n) <+> equals <+> ppr tv-                            <+> dcolon <+> ppr (varType tv)-   ppr (ATcTyCon tc)    = text "ATcTyCon" <+> ppr tc <+> dcolon <+> ppr (tyConKind tc)-   ppr (APromotionErr err) = text "APromotionErr" <+> ppr err---- | IdBindingInfo describes how an Id is bound.------ It is used for the following purposes:--- a) for static forms in TcExpr.checkClosedInStaticForm and--- b) to figure out when a nested binding can be generalised,---    in TcBinds.decideGeneralisationPlan.----data IdBindingInfo -- See Note [Meaning of IdBindingInfo and ClosedTypeId]-    = NotLetBound-    | ClosedLet-    | NonClosedLet-         RhsNames        -- Used for (static e) checks only-         ClosedTypeId    -- Used for generalisation checks-                         -- and for (static e) checks---- | IsGroupClosed describes a group of mutually-recursive bindings-data IsGroupClosed-  = IsGroupClosed-      (NameEnv RhsNames)  -- Free var info for the RHS of each binding in the goup-                          -- Used only for (static e) checks--      ClosedTypeId        -- True <=> all the free vars of the group are-                          --          imported or ClosedLet or-                          --          NonClosedLet with ClosedTypeId=True.-                          --          In particular, no tyvars, no NotLetBound--type RhsNames = NameSet   -- Names of variables, mentioned on the RHS of-                          -- a definition, that are not Global or ClosedLet--type ClosedTypeId = Bool-  -- See Note [Meaning of IdBindingInfo and ClosedTypeId]--{- Note [Meaning of IdBindingInfo]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-NotLetBound means that-  the Id is not let-bound (e.g. it is bound in a-  lambda-abstraction or in a case pattern)--ClosedLet means that-   - The Id is let-bound,-   - Any free term variables are also Global or ClosedLet-   - Its type has no free variables (NB: a top-level binding subject-     to the MR might have free vars in its type)-   These ClosedLets can definitely be floated to top level; and we-   may need to do so for static forms.--   Property:   ClosedLet-             is equivalent to-               NonClosedLet emptyNameSet True--(NonClosedLet (fvs::RhsNames) (cl::ClosedTypeId)) means that-   - The Id is let-bound--   - The fvs::RhsNames contains the free names of the RHS,-     excluding Global and ClosedLet ones.--   - For the ClosedTypeId field see Note [Bindings with closed types]--For (static e) to be valid, we need for every 'x' free in 'e',-that x's binding is floatable to the top level.  Specifically:-   * x's RhsNames must be empty-   * x's type has no free variables-See Note [Grand plan for static forms] in StaticPtrTable.hs.-This test is made in TcExpr.checkClosedInStaticForm.-Actually knowing x's RhsNames (rather than just its emptiness-or otherwise) is just so we can produce better error messages--Note [Bindings with closed types: ClosedTypeId]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider--  f x = let g ys = map not ys-        in ...--Can we generalise 'g' under the OutsideIn algorithm?  Yes,-because all g's free variables are top-level; that is they themselves-have no free type variables, and it is the type variables in the-environment that makes things tricky for OutsideIn generalisation.--Here's the invariant:-   If an Id has ClosedTypeId=True (in its IdBindingInfo), then-   the Id's type is /definitely/ closed (has no free type variables).-   Specifically,-       a) The Id's actual type is closed (has no free tyvars)-       b) Either the Id has a (closed) user-supplied type signature-          or all its free variables are Global/ClosedLet-             or NonClosedLet with ClosedTypeId=True.-          In particular, none are NotLetBound.--Why is (b) needed?   Consider-    \x. (x :: Int, let y = x+1 in ...)-Initially x::alpha.  If we happen to typecheck the 'let' before the-(x::Int), y's type will have a free tyvar; but if the other way round-it won't.  So we treat any let-bound variable with a free-non-let-bound variable as not ClosedTypeId, regardless of what the-free vars of its type actually are.--But if it has a signature, all is well:-   \x. ...(let { y::Int; y = x+1 } in-           let { v = y+2 } in ...)...-Here the signature on 'v' makes 'y' a ClosedTypeId, so we can-generalise 'v'.--Note that:--  * A top-level binding may not have ClosedTypeId=True, if it suffers-    from the MR--  * A nested binding may be closed (eg 'g' in the example we started-    with). Indeed, that's the point; whether a function is defined at-    top level or nested is orthogonal to the question of whether or-    not it is closed.--  * A binding may be non-closed because it mentions a lexically scoped-    *type variable*  Eg-        f :: forall a. blah-        f x = let g y = ...(y::a)...--Under OutsideIn we are free to generalise an Id all of whose free-variables have ClosedTypeId=True (or imported).  This is an extension-compared to the JFP paper on OutsideIn, which used "top-level" as a-proxy for "closed".  (It's not a good proxy anyway -- the MR can make-a top-level binding with a free type variable.)--Note [Type variables in the type environment]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The type environment has a binding for each lexically-scoped-type variable that is in scope.  For example--  f :: forall a. a -> a-  f x = (x :: a)--  g1 :: [a] -> a-  g1 (ys :: [b]) = head ys :: b--  g2 :: [Int] -> Int-  g2 (ys :: [c]) = head ys :: c--* The forall'd variable 'a' in the signature scopes over f's RHS.--* The pattern-bound type variable 'b' in 'g1' scopes over g1's-  RHS; note that it is bound to a skolem 'a' which is not itself-  lexically in scope.--* The pattern-bound type variable 'c' in 'g2' is bound to-  Int; that is, pattern-bound type variables can stand for-  arbitrary types. (see-    GHC proposal #128 "Allow ScopedTypeVariables to refer to types"-    https://github.com/ghc-proposals/ghc-proposals/pull/128,-  and the paper-    "Type variables in patterns", Haskell Symposium 2018.---This is implemented by the constructor-   ATyVar Name TcTyVar-in the type environment.--* The Name is the name of the original, lexically scoped type-  variable--* The TcTyVar is sometimes a skolem (like in 'f'), and sometimes-  a unification variable (like in 'g1', 'g2').  We never zonk the-  type environment so in the latter case it always stays as a-  unification variable, although that variable may be later-  unified with a type (such as Int in 'g2').--}--instance Outputable IdBindingInfo where-  ppr NotLetBound = text "NotLetBound"-  ppr ClosedLet = text "TopLevelLet"-  ppr (NonClosedLet fvs closed_type) =-    text "TopLevelLet" <+> ppr fvs <+> ppr closed_type--instance Outputable PromotionErr where-  ppr ClassPE                     = text "ClassPE"-  ppr TyConPE                     = text "TyConPE"-  ppr PatSynPE                    = text "PatSynPE"-  ppr FamDataConPE                = text "FamDataConPE"-  ppr (ConstrainedDataConPE pred) = text "ConstrainedDataConPE"-                                      <+> parens (ppr pred)-  ppr RecDataConPE                = text "RecDataConPE"-  ppr NoDataKindsTC               = text "NoDataKindsTC"-  ppr NoDataKindsDC               = text "NoDataKindsDC"--pprTcTyThingCategory :: TcTyThing -> SDoc-pprTcTyThingCategory (AGlobal thing)    = pprTyThingCategory thing-pprTcTyThingCategory (ATyVar {})        = text "Type variable"-pprTcTyThingCategory (ATcId {})         = text "Local identifier"-pprTcTyThingCategory (ATcTyCon {})     = text "Local tycon"-pprTcTyThingCategory (APromotionErr pe) = pprPECategory pe--pprPECategory :: PromotionErr -> SDoc-pprPECategory ClassPE                = text "Class"-pprPECategory TyConPE                = text "Type constructor"-pprPECategory PatSynPE               = text "Pattern synonym"-pprPECategory FamDataConPE           = text "Data constructor"-pprPECategory ConstrainedDataConPE{} = text "Data constructor"-pprPECategory RecDataConPE           = text "Data constructor"-pprPECategory NoDataKindsTC          = text "Type constructor"-pprPECategory NoDataKindsDC          = text "Data constructor"--{--************************************************************************-*                                                                      *-        Operations over ImportAvails-*                                                                      *-************************************************************************--}---- | 'ImportAvails' summarises what was imported from where, irrespective of--- whether the imported things are actually used or not.  It is used:------  * when processing the export list,------  * when constructing usage info for the interface file,------  * to identify the list of directly imported modules for initialisation---    purposes and for optimised overlap checking of family instances,------  * when figuring out what things are really unused----data ImportAvails-   = ImportAvails {-        imp_mods :: ImportedMods,-          --      = ModuleEnv [ImportedModsVal],-          -- ^ Domain is all directly-imported modules-          ---          -- 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,-          -- because we might be importing modules of the same name from-          -- different packages. (currently not the case, but might be in the-          -- future).--        imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface),-          -- ^ Home-package modules needed by the module being compiled-          ---          -- It doesn't matter whether any of these dependencies-          -- are actually /used/ when compiling the module; they-          -- are listed if they are below it at all.  For-          -- example, suppose M imports A which imports X.  Then-          -- compiling M might not need to consult X.hi, but X-          -- is still listed in M's dependencies.--        imp_dep_pkgs :: Set InstalledUnitId,-          -- ^ Packages needed by the module being compiled, whether directly,-          -- or via other modules in this package, or via modules imported-          -- from other packages.--        imp_trust_pkgs :: Set InstalledUnitId,-          -- ^ This is strictly a subset of imp_dep_pkgs and records the-          -- packages the current module needs to trust for Safe Haskell-          -- compilation to succeed. A package is required to be trusted if-          -- we are dependent on a trustworthy module in that package.-          -- While perhaps making imp_dep_pkgs a tuple of (UnitId, Bool)-          -- where True for the bool indicates the package is required to be-          -- trusted is the more logical  design, doing so complicates a lot-          -- of code not concerned with Safe Haskell.-          -- See Note [Tracking Trust Transitively] in GHC.Rename.Names--        imp_trust_own_pkg :: Bool,-          -- ^ Do we require that our own package is trusted?-          -- This is to handle efficiently the case where a Safe module imports-          -- a Trustworthy module that resides in the same package as it.-          -- See Note [Trust Own Package] in GHC.Rename.Names--        imp_orphs :: [Module],-          -- ^ Orphan modules below us in the import tree (and maybe including-          -- us for imported modules)--        imp_finsts :: [Module]-          -- ^ Family instance modules below us in the import tree (and maybe-          -- including us for imported modules)-      }--mkModDeps :: [(ModuleName, IsBootInterface)]-          -> ModuleNameEnv (ModuleName, IsBootInterface)-mkModDeps deps = foldl' add emptyUFM deps-               where-                 add env elt@(m,_) = addToUFM env m elt--modDepsElts-  :: ModuleNameEnv (ModuleName, IsBootInterface)-  -> [(ModuleName, IsBootInterface)]-modDepsElts = sort . nonDetEltsUFM-  -- It's OK to use nonDetEltsUFM here because sorting by module names-  -- restores determinism--emptyImportAvails :: ImportAvails-emptyImportAvails = ImportAvails { imp_mods          = emptyModuleEnv,-                                   imp_dep_mods      = emptyUFM,-                                   imp_dep_pkgs      = S.empty,-                                   imp_trust_pkgs    = S.empty,-                                   imp_trust_own_pkg = False,-                                   imp_orphs         = [],-                                   imp_finsts        = [] }---- | Union two ImportAvails------ This function is a key part of Import handling, basically--- for each import we create a separate ImportAvails structure--- and then union them all together with this function.-plusImportAvails ::  ImportAvails ->  ImportAvails ->  ImportAvails-plusImportAvails-  (ImportAvails { imp_mods = mods1,-                  imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1,-                  imp_trust_pkgs = tpkgs1, imp_trust_own_pkg = tself1,-                  imp_orphs = orphs1, imp_finsts = finsts1 })-  (ImportAvails { imp_mods = mods2,-                  imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,-                  imp_trust_pkgs = tpkgs2, imp_trust_own_pkg = tself2,-                  imp_orphs = orphs2, imp_finsts = finsts2 })-  = ImportAvails { imp_mods          = plusModuleEnv_C (++) mods1 mods2,-                   imp_dep_mods      = plusUFM_C plus_mod_dep dmods1 dmods2,-                   imp_dep_pkgs      = dpkgs1 `S.union` dpkgs2,-                   imp_trust_pkgs    = tpkgs1 `S.union` tpkgs2,-                   imp_trust_own_pkg = tself1 || tself2,-                   imp_orphs         = orphs1 `unionLists` orphs2,-                   imp_finsts        = finsts1 `unionLists` finsts2 }-  where-    plus_mod_dep r1@(m1, boot1) r2@(m2, boot2)-      | ASSERT2( m1 == m2, (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )-        boot1 = r2-      | otherwise = r1-      -- If either side can "see" a non-hi-boot interface, use that-      -- Reusing existing tuples saves 10% of allocations on test-      -- perf/compiler/MultiLayerModules--{--************************************************************************-*                                                                      *-\subsection{Where from}-*                                                                      *-************************************************************************--The @WhereFrom@ type controls where the renamer looks for an interface file--}--data WhereFrom-  = ImportByUser IsBootInterface        -- Ordinary user import (perhaps {-# SOURCE #-})-  | ImportBySystem                      -- Non user import.-  | ImportByPlugin                      -- Importing a plugin;-                                        -- See Note [Care with plugin imports] in GHC.Iface.Load--instance Outputable WhereFrom where-  ppr (ImportByUser is_boot) | is_boot     = text "{- SOURCE -}"-                             | otherwise   = empty-  ppr ImportBySystem                       = text "{- SYSTEM -}"-  ppr ImportByPlugin                       = text "{- PLUGIN -}"---{- *********************************************************************-*                                                                      *-                Type signatures-*                                                                      *-********************************************************************* -}---- These data types need to be here only because--- TcSimplify uses them, and TcSimplify is fairly--- low down in the module hierarchy--type TcSigFun  = Name -> Maybe TcSigInfo--data TcSigInfo = TcIdSig     TcIdSigInfo-               | TcPatSynSig TcPatSynInfo--data TcIdSigInfo   -- See Note [Complete and partial type signatures]-  = CompleteSig    -- A complete signature with no wildcards,-                   -- so the complete polymorphic type is known.-      { sig_bndr :: TcId          -- The polymorphic Id with that type--      , sig_ctxt :: UserTypeCtxt  -- In the case of type-class default methods,-                                  -- the Name in the FunSigCtxt is not the same-                                  -- as the TcId; the former is 'op', while the-                                  -- latter is '$dmop' or some such--      , sig_loc  :: SrcSpan       -- Location of the type signature-      }--  | PartialSig     -- A partial type signature (i.e. includes one or more-                   -- wildcards). In this case it doesn't make sense to give-                   -- the polymorphic Id, because we are going to /infer/ its-                   -- type, so we can't make the polymorphic Id ab-initio-      { psig_name  :: Name   -- Name of the function; used when report wildcards-      , psig_hs_ty :: LHsSigWcType GhcRn  -- The original partial signature in-                                          -- HsSyn form-      , sig_ctxt   :: UserTypeCtxt-      , sig_loc    :: SrcSpan            -- Location of the type signature-      }---{- Note [Complete and partial type signatures]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A type signature is partial when it contains one or more wildcards-(= type holes).  The wildcard can either be:-* A (type) wildcard occurring in sig_theta or sig_tau. These are-  stored in sig_wcs.-      f :: Bool -> _-      g :: Eq _a => _a -> _a -> Bool-* Or an extra-constraints wildcard, stored in sig_cts:-      h :: (Num a, _) => a -> a--A type signature is a complete type signature when there are no-wildcards in the type signature, i.e. iff sig_wcs is empty and-sig_extra_cts is Nothing.--}--data TcIdSigInst-  = TISI { sig_inst_sig :: TcIdSigInfo--         , sig_inst_skols :: [(Name, TcTyVar)]-               -- Instantiated type and kind variables, TyVarTvs-               -- The Name is the Name that the renamer chose;-               --   but the TcTyVar may come from instantiating-               --   the type and hence have a different unique.-               -- No need to keep track of whether they are truly lexically-               --   scoped because the renamer has named them uniquely-               -- See Note [Binding scoped type variables] in TcSigs-               ---               -- NB: The order of sig_inst_skols is irrelevant-               --     for a CompleteSig, but for a PartialSig see-               --     Note [Quantified variables in partial type signatures]--         , sig_inst_theta  :: TcThetaType-               -- Instantiated theta.  In the case of a-               -- PartialSig, sig_theta does not include-               -- the extra-constraints wildcard--         , sig_inst_tau :: TcSigmaType   -- Instantiated tau-               -- See Note [sig_inst_tau may be polymorphic]--         -- Relevant for partial signature only-         , sig_inst_wcs   :: [(Name, TcTyVar)]-               -- Like sig_inst_skols, but for /named/ wildcards (_a etc).-               -- The named wildcards scope over the binding, and hence-               -- their Names may appear in type signatures in the binding--         , sig_inst_wcx   :: Maybe TcType-               -- Extra-constraints wildcard to fill in, if any-               -- If this exists, it is surely of the form (meta_tv |> co)-               -- (where the co might be reflexive). This is filled in-               -- only from the return value of TcHsType.tcAnonWildCardOcc-         }--{- Note [sig_inst_tau may be polymorphic]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Note that "sig_inst_tau" might actually be a polymorphic type,-if the original function had a signature like-   forall a. Eq a => forall b. Ord b => ....-But that's ok: tcMatchesFun (called by tcRhs) can deal with that-It happens, too!  See Note [Polymorphic methods] in TcClassDcl.--Note [Quantified variables in partial type signatures]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider-   f :: forall a b. _ -> a -> _ -> b-   f (x,y) p q = q--Then we expect f's final type to be-  f :: forall {x,y}. forall a b. (x,y) -> a -> b -> b--Note that x,y are Inferred, and can't be use for visible type-application (VTA).  But a,b are Specified, and remain Specified-in the final type, so we can use VTA for them.  (Exception: if-it turns out that a's kind mentions b we need to reorder them-with scopedSort.)--The sig_inst_skols of the TISI from a partial signature records-that original order, and is used to get the variables of f's-final type in the correct order.---Note [Wildcards in partial signatures]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The wildcards in psig_wcs may stand for a type mentioning-the universally-quantified tyvars of psig_ty--E.g.  f :: forall a. _ -> a-      f x = x-We get sig_inst_skols = [a]-       sig_inst_tau   = _22 -> a-       sig_inst_wcs   = [_22]-and _22 in the end is unified with the type 'a'--Moreover the kind of a wildcard in sig_inst_wcs may mention-the universally-quantified tyvars sig_inst_skols-e.g.   f :: t a -> t _-Here we get-   sig_inst_skols = [k:*, (t::k ->*), (a::k)]-   sig_inst_tau   = t a -> t _22-   sig_inst_wcs   = [ _22::k ]--}--data TcPatSynInfo-  = TPSI {-        patsig_name           :: Name,-        patsig_implicit_bndrs :: [TyVarBinder], -- Implicitly-bound kind vars (Inferred) and-                                                -- implicitly-bound type vars (Specified)-          -- See Note [The pattern-synonym signature splitting rule] in TcPatSyn-        patsig_univ_bndrs     :: [TyVar],       -- Bound by explicit user forall-        patsig_req            :: TcThetaType,-        patsig_ex_bndrs       :: [TyVar],       -- Bound by explicit user forall-        patsig_prov           :: TcThetaType,-        patsig_body_ty        :: TcSigmaType-    }--instance Outputable TcSigInfo where-  ppr (TcIdSig     idsi) = ppr idsi-  ppr (TcPatSynSig tpsi) = text "TcPatSynInfo" <+> ppr tpsi--instance Outputable TcIdSigInfo where-    ppr (CompleteSig { sig_bndr = bndr })-        = ppr bndr <+> dcolon <+> ppr (idType bndr)-    ppr (PartialSig { psig_name = name, psig_hs_ty = hs_ty })-        = text "psig" <+> ppr name <+> dcolon <+> ppr hs_ty--instance Outputable TcIdSigInst where-    ppr (TISI { sig_inst_sig = sig, sig_inst_skols = skols-              , sig_inst_theta = theta, sig_inst_tau = tau })-        = hang (ppr sig) 2 (vcat [ ppr skols, ppr theta <+> darrow <+> ppr tau ])--instance Outputable TcPatSynInfo where-    ppr (TPSI{ patsig_name = name}) = ppr name--isPartialSig :: TcIdSigInst -> Bool-isPartialSig (TISI { sig_inst_sig = PartialSig {} }) = True-isPartialSig _                                       = False---- | No signature or a partial signature-hasCompleteSig :: TcSigFun -> Name -> Bool-hasCompleteSig sig_fn name-  = case sig_fn name of-      Just (TcIdSig (CompleteSig {})) -> True-      _                               -> False---{--Constraint Solver Plugins----------------------------}--type TcPluginSolver = [Ct]    -- given-                   -> [Ct]    -- derived-                   -> [Ct]    -- wanted-                   -> TcPluginM TcPluginResult--newtype TcPluginM a = TcPluginM (EvBindsVar -> TcM a) deriving (Functor)--instance Applicative TcPluginM where-  pure x = TcPluginM (const $ pure x)-  (<*>) = ap--instance Monad TcPluginM where-  TcPluginM m >>= k =-    TcPluginM (\ ev -> do a <- m ev-                          runTcPluginM (k a) ev)--instance MonadFail TcPluginM where-  fail x   = TcPluginM (const $ fail x)--runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a-runTcPluginM (TcPluginM m) = m---- | This function provides an escape for direct access to--- the 'TcM` monad.  It should not be used lightly, and--- the provided 'TcPluginM' API should be favoured instead.-unsafeTcPluginTcM :: TcM a -> TcPluginM a-unsafeTcPluginTcM = TcPluginM . const---- | Access the 'EvBindsVar' carried by the 'TcPluginM' during--- constraint solving.  Returns 'Nothing' if invoked during--- 'tcPluginInit' or 'tcPluginStop'.-getEvBindsTcPluginM :: TcPluginM EvBindsVar-getEvBindsTcPluginM = TcPluginM return---data TcPlugin = forall s. TcPlugin-  { tcPluginInit  :: TcPluginM s-    -- ^ Initialize plugin, when entering type-checker.--  , tcPluginSolve :: s -> TcPluginSolver-    -- ^ Solve some constraints.-    -- TODO: WRITE MORE DETAILS ON HOW THIS WORKS.--  , tcPluginStop  :: s -> TcPluginM ()-   -- ^ Clean up after the plugin, when exiting the type-checker.-  }--data TcPluginResult-  = TcPluginContradiction [Ct]-    -- ^ The plugin found a contradiction.-    -- The returned constraints are removed from the inert set,-    -- and recorded as insoluble.--  | TcPluginOk [(EvTerm,Ct)] [Ct]-    -- ^ The first field is for constraints that were solved.-    -- These are removed from the inert set,-    -- and the evidence for them is recorded.-    -- The second field contains new work, that should be processed by-    -- the constraint solver.--{- *********************************************************************-*                                                                      *-                        Role annotations-*                                                                      *-********************************************************************* -}--type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)--mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv-mkRoleAnnotEnv role_annot_decls- = mkNameEnv [ (name, ra_decl)-             | ra_decl <- role_annot_decls-             , let name = roleAnnotDeclName (unLoc ra_decl)-             , not (isUnboundName name) ]-       -- Some of the role annots will be unbound;-       -- we don't wish to include these--emptyRoleAnnotEnv :: RoleAnnotEnv-emptyRoleAnnotEnv = emptyNameEnv--lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)-lookupRoleAnnot = lookupNameEnv--getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]-getRoleAnnots bndrs role_env-  = mapMaybe (lookupRoleAnnot role_env) bndrs
− compiler/typecheck/TcRnTypes.hs-boot 
@@ -1,12 +0,0 @@-module TcRnTypes where--import TcType-import GHC.Types.SrcLoc--data TcLclEnv--setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv-getLclEnvTcLevel :: TcLclEnv -> TcLevel--setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv-getLclEnvLoc :: TcLclEnv -> RealSrcSpan
− compiler/typecheck/TcType.hs 
@@ -1,2491 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[TcType]{Types used in the typechecker}--This module provides the Type interface for front-end parts of the-compiler.  These parts--        * treat "source types" as opaque:-                newtypes, and predicates are meaningful.-        * look through usage types--The "tc" prefix is for "TypeChecker", because the type checker-is the principal client.--}--{-# LANGUAGE CPP, ScopedTypeVariables, MultiWayIf, FlexibleContexts #-}-{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}--module TcType (-  ---------------------------------  -- Types-  TcType, TcSigmaType, TcRhoType, TcTauType, TcPredType, TcThetaType,-  TcTyVar, TcTyVarSet, TcDTyVarSet, TcTyCoVarSet, TcDTyCoVarSet,-  TcKind, TcCoVar, TcTyCoVar, TcTyVarBinder, TcTyCon,-  KnotTied,--  ExpType(..), InferResult(..), ExpSigmaType, ExpRhoType, mkCheckExpType,--  SyntaxOpType(..), synKnownType, mkSynFunTys,--  -- TcLevel-  TcLevel(..), topTcLevel, pushTcLevel, isTopTcLevel,-  strictlyDeeperThan, sameDepthAs,-  tcTypeLevel, tcTyVarLevel, maxTcLevel,-  promoteSkolem, promoteSkolemX, promoteSkolemsX,-  ---------------------------------  -- MetaDetails-  TcTyVarDetails(..), pprTcTyVarDetails, vanillaSkolemTv, superSkolemTv,-  MetaDetails(Flexi, Indirect), MetaInfo(..),-  isImmutableTyVar, isSkolemTyVar, isMetaTyVar,  isMetaTyVarTy, isTyVarTy,-  tcIsTcTyVar, isTyVarTyVar, isOverlappableTyVar,  isTyConableTyVar,-  isFskTyVar, isFmvTyVar, isFlattenTyVar,-  isAmbiguousTyVar, metaTyVarRef, metaTyVarInfo,-  isFlexi, isIndirect, isRuntimeUnkSkol,-  metaTyVarTcLevel, setMetaTyVarTcLevel, metaTyVarTcLevel_maybe,-  isTouchableMetaTyVar,-  isFloatedTouchableMetaTyVar,-  findDupTyVarTvs, mkTyVarNamePairs,--  ---------------------------------  -- Builders-  mkPhiTy, mkInfSigmaTy, mkSpecSigmaTy, mkSigmaTy,-  mkTcAppTy, mkTcAppTys, mkTcCastTy,--  ---------------------------------  -- Splitters-  -- These are important because they do not look through newtypes-  getTyVar,-  tcSplitForAllTy_maybe,-  tcSplitForAllTys, tcSplitForAllTysSameVis,-  tcSplitPiTys, tcSplitPiTy_maybe, tcSplitForAllVarBndrs,-  tcSplitPhiTy, tcSplitPredFunTy_maybe,-  tcSplitFunTy_maybe, tcSplitFunTys, tcFunArgTy, tcFunResultTy, tcFunResultTyN,-  tcSplitFunTysN,-  tcSplitTyConApp, tcSplitTyConApp_maybe,-  tcTyConAppTyCon, tcTyConAppTyCon_maybe, tcTyConAppArgs,-  tcSplitAppTy_maybe, tcSplitAppTy, tcSplitAppTys, tcRepSplitAppTy_maybe,-  tcRepGetNumAppTys,-  tcGetCastedTyVar_maybe, tcGetTyVar_maybe, tcGetTyVar,-  tcSplitSigmaTy, tcSplitNestedSigmaTys, tcDeepSplitSigmaTy_maybe,--  ----------------------------------  -- Predicates.-  -- Again, newtypes are opaque-  eqType, eqTypes, nonDetCmpType, nonDetCmpTypes, eqTypeX,-  pickyEqType, tcEqType, tcEqKind, tcEqTypeNoKindCheck, tcEqTypeVis,-  isSigmaTy, isRhoTy, isRhoExpTy, isOverloadedTy,-  isFloatingTy, isDoubleTy, isFloatTy, isIntTy, isWordTy, isStringTy,-  isIntegerTy, isBoolTy, isUnitTy, isCharTy, isCallStackTy, isCallStackPred,-  hasIPPred, isTauTy, isTauTyCon, tcIsTyVarTy, tcIsForAllTy,-  isPredTy, isTyVarClassPred, isTyVarHead, isInsolubleOccursCheck,-  checkValidClsArgs, hasTyVarHead,-  isRigidTy, isAlmostFunctionFree,--  ----------------------------------  -- Misc type manipulators--  deNoteType,-  orphNamesOfType, orphNamesOfCo,-  orphNamesOfTypes, orphNamesOfCoCon,-  getDFunTyKey, evVarPred,--  ----------------------------------  -- Predicate types-  mkMinimalBySCs, transSuperClasses,-  pickQuantifiablePreds, pickCapturedPreds,-  immSuperClasses, boxEqPred,-  isImprovementPred,--  -- * Finding type instances-  tcTyFamInsts, tcTyFamInstsAndVis, tcTyConAppTyFamInstsAndVis, isTyFamFree,--  -- * Finding "exact" (non-dead) type variables-  exactTyCoVarsOfType, exactTyCoVarsOfTypes,-  anyRewritableTyVar,--  ----------------------------------  -- Foreign import and export-  isFFIArgumentTy,     -- :: DynFlags -> Safety -> Type -> Bool-  isFFIImportResultTy, -- :: DynFlags -> Type -> Bool-  isFFIExportResultTy, -- :: Type -> Bool-  isFFIExternalTy,     -- :: Type -> Bool-  isFFIDynTy,          -- :: Type -> Type -> Bool-  isFFIPrimArgumentTy, -- :: DynFlags -> Type -> Bool-  isFFIPrimResultTy,   -- :: DynFlags -> Type -> Bool-  isFFILabelTy,        -- :: Type -> Bool-  isFFITy,             -- :: Type -> Bool-  isFunPtrTy,          -- :: Type -> Bool-  tcSplitIOType_maybe, -- :: Type -> Maybe Type--  ---------------------------------  -- Reexported from Kind-  Kind, tcTypeKind,-  liftedTypeKind,-  constraintKind,-  isLiftedTypeKind, isUnliftedTypeKind, classifiesTypeWithValues,--  ---------------------------------  -- Reexported from Type-  Type, PredType, ThetaType, TyCoBinder,-  ArgFlag(..), AnonArgFlag(..), ForallVisFlag(..),--  mkForAllTy, mkForAllTys, mkTyCoInvForAllTys, mkSpecForAllTys, mkTyCoInvForAllTy,-  mkInvForAllTy, mkInvForAllTys,-  mkVisFunTy, mkVisFunTys, mkInvisFunTy, mkInvisFunTys,-  mkTyConApp, mkAppTy, mkAppTys,-  mkTyConTy, mkTyVarTy, mkTyVarTys,-  mkTyCoVarTy, mkTyCoVarTys,--  isClassPred, isEqPrimPred, isIPPred, isEqPred, isEqPredClass,-  mkClassPred,-  tcSplitDFunTy, tcSplitDFunHead, tcSplitMethodTy,-  isRuntimeRepVar, isKindLevPoly,-  isVisibleBinder, isInvisibleBinder,--  -- Type substitutions-  TCvSubst(..),         -- Representation visible to a few friends-  TvSubstEnv, emptyTCvSubst, mkEmptyTCvSubst,-  zipTvSubst,-  mkTvSubstPrs, notElemTCvSubst, unionTCvSubst,-  getTvSubstEnv, setTvSubstEnv, getTCvInScope, extendTCvInScope,-  extendTCvInScopeList, extendTCvInScopeSet, extendTvSubstAndInScope,-  Type.lookupTyVar, Type.extendTCvSubst, Type.substTyVarBndr,-  Type.extendTvSubst,-  isInScope, mkTCvSubst, mkTvSubst, zipTyEnv, zipCoEnv,-  Type.substTy, substTys, substTyWith, substTyWithCoVars,-  substTyAddInScope,-  substTyUnchecked, substTysUnchecked, substThetaUnchecked,-  substTyWithUnchecked,-  substCoUnchecked, substCoWithUnchecked,-  substTheta,--  isUnliftedType,       -- Source types are always lifted-  isUnboxedTupleType,   -- Ditto-  isPrimitiveType,--  tcView, coreView,--  tyCoVarsOfType, tyCoVarsOfTypes, closeOverKinds,-  tyCoFVsOfType, tyCoFVsOfTypes,-  tyCoVarsOfTypeDSet, tyCoVarsOfTypesDSet, closeOverKindsDSet,-  tyCoVarsOfTypeList, tyCoVarsOfTypesList,-  noFreeVarsOfType,--  ---------------------------------  pprKind, pprParendKind, pprSigmaType,-  pprType, pprParendType, pprTypeApp, pprTyThingCategory, tyThingCategory,-  pprTheta, pprParendTheta, pprThetaArrowTy, pprClassPred,-  pprTCvBndr, pprTCvBndrs,--  TypeSize, sizeType, sizeTypes, scopedSort,--  ----------------------------------  -- argument visibility-  tcTyConVisibilities, isNextTyConArgVisible, isNextArgVisible--  ) where--#include "HsVersions.h"---- friends:-import GhcPrelude--import GHC.Core.TyCo.Rep-import GHC.Core.TyCo.Subst ( mkTvSubst, substTyWithCoVars )-import GHC.Core.TyCo.FVs-import GHC.Core.TyCo.Ppr-import GHC.Core.Class-import GHC.Types.Var-import GHC.Types.ForeignCall-import GHC.Types.Var.Set-import GHC.Core.Coercion-import GHC.Core.Type as Type-import GHC.Core.Predicate-import GHC.Types.RepType-import GHC.Core.TyCon---- others:-import GHC.Driver.Session-import GHC.Core.FVs-import GHC.Types.Name as Name-            -- We use this to make dictionaries for type literals.-            -- Perhaps there's a better way to do this?-import GHC.Types.Name.Set-import GHC.Types.Var.Env-import PrelNames-import TysWiredIn( coercibleClass, eqClass, heqClass, unitTyCon, unitTyConKey-                 , listTyCon, constraintKind )-import GHC.Types.Basic-import Util-import Maybes-import ListSetOps ( getNth, findDupsEq )-import Outputable-import FastString-import ErrUtils( Validity(..), MsgDoc, isValid )-import qualified GHC.LanguageExtensions as LangExt--import Data.List  ( mapAccumL )--- import Data.Functor.Identity( Identity(..) )-import Data.IORef-import Data.List.NonEmpty( NonEmpty(..) )--{--************************************************************************-*                                                                      *-              Types-*                                                                      *-************************************************************************--The type checker divides the generic Type world into the-following more structured beasts:--sigma ::= forall tyvars. phi-        -- A sigma type is a qualified type-        ---        -- Note that even if 'tyvars' is empty, theta-        -- may not be: e.g.   (?x::Int) => Int--        -- Note that 'sigma' is in prenex form:-        -- all the foralls are at the front.-        -- A 'phi' type has no foralls to the right of-        -- an arrow--phi :: theta => rho--rho ::= sigma -> rho-     |  tau---- A 'tau' type has no quantification anywhere--- Note that the args of a type constructor must be taus-tau ::= tyvar-     |  tycon tau_1 .. tau_n-     |  tau_1 tau_2-     |  tau_1 -> tau_2---- In all cases, a (saturated) type synonym application is legal,--- provided it expands to the required form.--Note [TcTyVars and TyVars in the typechecker]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The typechecker uses a lot of type variables with special properties,-notably being a unification variable with a mutable reference.  These-use the 'TcTyVar' variant of Var.Var.--Note, though, that a /bound/ type variable can (and probably should)-be a TyVar.  E.g-    forall a. a -> a-Here 'a' is really just a deBruijn-number; it certainly does not have-a significant TcLevel (as every TcTyVar does).  So a forall-bound type-variable should be TyVars; and hence a TyVar can appear free in a TcType.--The type checker and constraint solver can also encounter /free/ type-variables that use the 'TyVar' variant of Var.Var, for a couple of-reasons:--  - When typechecking a class decl, say-       class C (a :: k) where-          foo :: T a -> Int-    We have first kind-check the header; fix k and (a:k) to be-    TyVars, bring 'k' and 'a' into scope, and kind check the-    signature for 'foo'.  In doing so we call solveEqualities to-    solve any kind equalities in foo's signature.  So the solver-    may see free occurrences of 'k'.--    See calls to tcExtendTyVarEnv for other places that ordinary-    TyVars are bought into scope, and hence may show up in the types-    and kinds generated by TcHsType.--  - The pattern-match overlap checker calls the constraint solver,-    long after TcTyVars have been zonked away--It's convenient to simply treat these TyVars as skolem constants,-which of course they are.  We give them a level number of "outermost",-so they behave as global constants.  Specifically:--* Var.tcTyVarDetails succeeds on a TyVar, returning-  vanillaSkolemTv, as well as on a TcTyVar.--* tcIsTcTyVar returns True for both TyVar and TcTyVar variants-  of Var.Var.  The "tc" prefix means "a type variable that can be-  encountered by the typechecker".--This is a bit of a change from an earlier era when we remoselessly-insisted on real TcTyVars in the type checker.  But that seems-unnecessary (for skolems, TyVars are fine) and it's now very hard-to guarantee, with the advent of kind equalities.--Note [Coercion variables in free variable lists]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-There are several places in the GHC codebase where functions like-tyCoVarsOfType, tyCoVarsOfCt, et al. are used to compute the free type-variables of a type. The "Co" part of these functions' names shouldn't be-dismissed, as it is entirely possible that they will include coercion variables-in addition to type variables! As a result, there are some places in TcType-where we must take care to check that a variable is a _type_ variable (using-isTyVar) before calling tcTyVarDetails--a partial function that is not defined-for coercion variables--on the variable. Failing to do so led to-GHC #12785.--}---- See Note [TcTyVars and TyVars in the typechecker]-type TcCoVar = CoVar    -- Used only during type inference-type TcType = Type      -- A TcType can have mutable type variables-type TcTyCoVar = Var    -- Either a TcTyVar or a CoVar-        -- Invariant on ForAllTy in TcTypes:-        --      forall a. T-        -- a cannot occur inside a MutTyVar in T; that is,-        -- T is "flattened" before quantifying over a--type TcTyVarBinder   = TyVarBinder-type TcTyCon         = TyCon   -- these can be the TcTyCon constructor---- These types do not have boxy type variables in them-type TcPredType     = PredType-type TcThetaType    = ThetaType-type TcSigmaType    = TcType-type TcRhoType      = TcType  -- Note [TcRhoType]-type TcTauType      = TcType-type TcKind         = Kind-type TcTyVarSet     = TyVarSet-type TcTyCoVarSet   = TyCoVarSet-type TcDTyVarSet    = DTyVarSet-type TcDTyCoVarSet  = DTyCoVarSet--{- *********************************************************************-*                                                                      *-          ExpType: an "expected type" in the type checker-*                                                                      *-********************************************************************* -}---- | An expected type to check against during type-checking.--- See Note [ExpType] in TcMType, where you'll also find manipulators.-data ExpType = Check TcType-             | Infer !InferResult--data InferResult-  = IR { ir_uniq :: Unique  -- For debugging only--       , ir_lvl  :: TcLevel -- See Note [TcLevel of ExpType] in TcMType--       , ir_inst :: Bool-         -- True <=> deeply instantiate before returning-         --           i.e. return a RhoType-         -- False <=> do not instantiate before returning-         --           i.e. return a SigmaType-         -- See Note [Deep instantiation of InferResult] in TcUnify--       , ir_ref  :: IORef (Maybe TcType) }-         -- The type that fills in this hole should be a Type,-         -- that is, its kind should be (TYPE rr) for some rr--type ExpSigmaType = ExpType-type ExpRhoType   = ExpType--instance Outputable ExpType where-  ppr (Check ty) = text "Check" <> braces (ppr ty)-  ppr (Infer ir) = ppr ir--instance Outputable InferResult where-  ppr (IR { ir_uniq = u, ir_lvl = lvl-          , ir_inst = inst })-    = text "Infer" <> braces (ppr u <> comma <> ppr lvl <+> ppr inst)---- | Make an 'ExpType' suitable for checking.-mkCheckExpType :: TcType -> ExpType-mkCheckExpType = Check---{- *********************************************************************-*                                                                      *-          SyntaxOpType-*                                                                      *-********************************************************************* -}---- | What to expect for an argument to a rebindable-syntax operator.--- Quite like 'Type', but allows for holes to be filled in by tcSyntaxOp.--- The callback called from tcSyntaxOp gets a list of types; the meaning--- of these types is determined by a left-to-right depth-first traversal--- of the 'SyntaxOpType' tree. So if you pass in------ > SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny------ you'll get three types back: one for the first 'SynAny', the /element/--- type of the list, and one for the last 'SynAny'. You don't get anything--- for the 'SynType', because you've said positively that it should be an--- Int, and so it shall be.------ This is defined here to avoid defining it in TcExpr.hs-boot.-data SyntaxOpType-  = SynAny     -- ^ Any type-  | SynRho     -- ^ A rho type, deeply skolemised or instantiated as appropriate-  | SynList    -- ^ A list type. You get back the element type of the list-  | SynFun SyntaxOpType SyntaxOpType-               -- ^ A function.-  | SynType ExpType   -- ^ A known type.-infixr 0 `SynFun`---- | Like 'SynType' but accepts a regular TcType-synKnownType :: TcType -> SyntaxOpType-synKnownType = SynType . mkCheckExpType---- | Like 'mkFunTys' but for 'SyntaxOpType'-mkSynFunTys :: [SyntaxOpType] -> ExpType -> SyntaxOpType-mkSynFunTys arg_tys res_ty = foldr SynFun (SynType res_ty) arg_tys---{--Note [TcRhoType]-~~~~~~~~~~~~~~~~-A TcRhoType has no foralls or contexts at the top, or to the right of an arrow-  YES    (forall a. a->a) -> Int-  NO     forall a. a ->  Int-  NO     Eq a => a -> a-  NO     Int -> forall a. a -> Int---************************************************************************-*                                                                      *-        TyVarDetails, MetaDetails, MetaInfo-*                                                                      *-************************************************************************--TyVarDetails gives extra info about type variables, used during type-checking.  It's attached to mutable type variables only.-It's knot-tied back to Var.hs.  There is no reason in principle-why Var.hs shouldn't actually have the definition, but it "belongs" here.--Note [Signature skolems]-~~~~~~~~~~~~~~~~~~~~~~~~-A TyVarTv is a specialised variant of TauTv, with the following invariants:--    * A TyVarTv can be unified only with a TyVar,-      not with any other type--    * Its MetaDetails, if filled in, will always be another TyVarTv-      or a SkolemTv--TyVarTvs are only distinguished to improve error messages.-Consider this--  data T (a:k1) = MkT (S a)-  data S (b:k2) = MkS (T b)--When doing kind inference on {S,T} we don't want *skolems* for k1,k2,-because they end up unifying; we want those TyVarTvs again.---Note [TyVars and TcTyVars during type checking]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The Var type has constructors TyVar and TcTyVar.  They are used-as follows:--* TcTyVar: used /only/ during type checking.  Should never appear-  afterwards.  May contain a mutable field, in the MetaTv case.--* TyVar: is never seen by the constraint solver, except locally-  inside a type like (forall a. [a] ->[a]), where 'a' is a TyVar.-  We instantiate these with TcTyVars before exposing the type-  to the constraint solver.--I have swithered about the latter invariant, excluding TyVars from the-constraint solver.  It's not strictly essential, and indeed-(historically but still there) Var.tcTyVarDetails returns-vanillaSkolemTv for a TyVar.--But ultimately I want to seeparate Type from TcType, and in that case-we would need to enforce the separation.--}---- A TyVarDetails is inside a TyVar--- See Note [TyVars and TcTyVars]-data TcTyVarDetails-  = SkolemTv      -- A skolem-       TcLevel    -- Level of the implication that binds it-                  -- See TcUnify Note [Deeper level on the left] for-                  --     how this level number is used-       Bool       -- True <=> this skolem type variable can be overlapped-                  --          when looking up instances-                  -- See Note [Binding when looking up instances] in GHC.Core.InstEnv--  | RuntimeUnk    -- Stands for an as-yet-unknown type in the GHCi-                  -- interactive context--  | MetaTv { mtv_info  :: MetaInfo-           , mtv_ref   :: IORef MetaDetails-           , mtv_tclvl :: TcLevel }  -- See Note [TcLevel and untouchable type variables]--vanillaSkolemTv, superSkolemTv :: TcTyVarDetails--- See Note [Binding when looking up instances] in GHC.Core.InstEnv-vanillaSkolemTv = SkolemTv topTcLevel False  -- Might be instantiated-superSkolemTv   = SkolemTv topTcLevel True   -- Treat this as a completely distinct type-                  -- The choice of level number here is a bit dodgy, but-                  -- topTcLevel works in the places that vanillaSkolemTv is used--instance Outputable TcTyVarDetails where-  ppr = pprTcTyVarDetails--pprTcTyVarDetails :: TcTyVarDetails -> SDoc--- For debugging-pprTcTyVarDetails (RuntimeUnk {})      = text "rt"-pprTcTyVarDetails (SkolemTv lvl True)  = text "ssk" <> colon <> ppr lvl-pprTcTyVarDetails (SkolemTv lvl False) = text "sk"  <> colon <> ppr lvl-pprTcTyVarDetails (MetaTv { mtv_info = info, mtv_tclvl = tclvl })-  = ppr info <> colon <> ppr tclvl--------------------------------data MetaDetails-  = Flexi  -- Flexi type variables unify to become Indirects-  | Indirect TcType--data MetaInfo-   = TauTv         -- This MetaTv is an ordinary unification variable-                   -- A TauTv is always filled in with a tau-type, which-                   -- never contains any ForAlls.--   | TyVarTv       -- A variant of TauTv, except that it should not be-                   --   unified with a type, only with a type variable-                   -- See Note [Signature skolems]--   | FlatMetaTv    -- A flatten meta-tyvar-                   -- It is a meta-tyvar, but it is always untouchable, with level 0-                   -- See Note [The flattening story] in TcFlatten--   | FlatSkolTv    -- A flatten skolem tyvar-                   -- Just like FlatMetaTv, but is completely "owned" by-                   --   its Given CFunEqCan.-                   -- It is filled in /only/ by unflattenGivens-                   -- See Note [The flattening story] in TcFlatten--instance Outputable MetaDetails where-  ppr Flexi         = text "Flexi"-  ppr (Indirect ty) = text "Indirect" <+> ppr ty--instance Outputable MetaInfo where-  ppr TauTv         = text "tau"-  ppr TyVarTv       = text "tyv"-  ppr FlatMetaTv    = text "fmv"-  ppr FlatSkolTv    = text "fsk"--{- *********************************************************************-*                                                                      *-                Untouchable type variables-*                                                                      *-********************************************************************* -}--newtype TcLevel = TcLevel Int deriving( Eq, Ord )-  -- See Note [TcLevel and untouchable type variables] for what this Int is-  -- See also Note [TcLevel assignment]--{--Note [TcLevel and untouchable type variables]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-* Each unification variable (MetaTv)-  and each Implication-  has a level number (of type TcLevel)--* INVARIANTS.  In a tree of Implications,--    (ImplicInv) The level number (ic_tclvl) of an Implication is-                STRICTLY GREATER THAN that of its parent--    (SkolInv)   The level number of the skolems (ic_skols) of an-                Implication is equal to the level of the implication-                itself (ic_tclvl)--    (GivenInv)  The level number of a unification variable appearing-                in the 'ic_given' of an implication I should be-                STRICTLY LESS THAN the ic_tclvl of I--    (WantedInv) The level number of a unification variable appearing-                in the 'ic_wanted' of an implication I should be-                LESS THAN OR EQUAL TO the ic_tclvl of I-                See Note [WantedInv]--* A unification variable is *touchable* if its level number-  is EQUAL TO that of its immediate parent implication,-  and it is a TauTv or TyVarTv (but /not/ FlatMetaTv or FlatSkolTv)--Note [WantedInv]-~~~~~~~~~~~~~~~~-Why is WantedInv important?  Consider this implication, where-the constraint (C alpha[3]) disobeys WantedInv:--   forall[2] a. blah => (C alpha[3])-                        (forall[3] b. alpha[3] ~ b)--We can unify alpha:=b in the inner implication, because 'alpha' is-touchable; but then 'b' has excaped its scope into the outer implication.--Note [Skolem escape prevention]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We only unify touchable unification variables.  Because of-(WantedInv), there can be no occurrences of the variable further out,-so the unification can't cause the skolems to escape. Example:-     data T = forall a. MkT a (a->Int)-     f x (MkT v f) = length [v,x]-We decide (x::alpha), and generate an implication like-      [1]forall a. (a ~ alpha[0])-But we must not unify alpha:=a, because the skolem would escape.--For the cases where we DO want to unify, we rely on floating the-equality.   Example (with same T)-     g x (MkT v f) = x && True-We decide (x::alpha), and generate an implication like-      [1]forall a. (Bool ~ alpha[0])-We do NOT unify directly, bur rather float out (if the constraint-does not mention 'a') to get-      (Bool ~ alpha[0]) /\ [1]forall a.()-and NOW we can unify alpha.--The same idea of only unifying touchables solves another problem.-Suppose we had-   (F Int ~ uf[0])  /\  [1](forall a. C a => F Int ~ beta[1])-In this example, beta is touchable inside the implication. The-first solveSimpleWanteds step leaves 'uf' un-unified. Then we move inside-the implication where a new constraint-       uf  ~  beta-emerges. If we (wrongly) spontaneously solved it to get uf := beta,-the whole implication disappears but when we pop out again we are left with-(F Int ~ uf) which will be unified by our final zonking stage and-uf will get unified *once more* to (F Int).--Note [TcLevel assignment]-~~~~~~~~~~~~~~~~~~~~~~~~~-We arrange the TcLevels like this--   0   Top level-   1   First-level implication constraints-   2   Second-level implication constraints-   ...etc...--}--maxTcLevel :: TcLevel -> TcLevel -> TcLevel-maxTcLevel (TcLevel a) (TcLevel b) = TcLevel (a `max` b)--topTcLevel :: TcLevel--- See Note [TcLevel assignment]-topTcLevel = TcLevel 0   -- 0 = outermost level--isTopTcLevel :: TcLevel -> Bool-isTopTcLevel (TcLevel 0) = True-isTopTcLevel _           = False--pushTcLevel :: TcLevel -> TcLevel--- See Note [TcLevel assignment]-pushTcLevel (TcLevel us) = TcLevel (us + 1)--strictlyDeeperThan :: TcLevel -> TcLevel -> Bool-strictlyDeeperThan (TcLevel tv_tclvl) (TcLevel ctxt_tclvl)-  = tv_tclvl > ctxt_tclvl--sameDepthAs :: TcLevel -> TcLevel -> Bool-sameDepthAs (TcLevel ctxt_tclvl) (TcLevel tv_tclvl)-  = ctxt_tclvl == tv_tclvl   -- NB: invariant ctxt_tclvl >= tv_tclvl-                             --     So <= would be equivalent--checkTcLevelInvariant :: TcLevel -> TcLevel -> Bool--- Checks (WantedInv) from Note [TcLevel and untouchable type variables]-checkTcLevelInvariant (TcLevel ctxt_tclvl) (TcLevel tv_tclvl)-  = ctxt_tclvl >= tv_tclvl---- Returns topTcLevel for non-TcTyVars-tcTyVarLevel :: TcTyVar -> TcLevel-tcTyVarLevel tv-  = case tcTyVarDetails tv of-          MetaTv { mtv_tclvl = tv_lvl } -> tv_lvl-          SkolemTv tv_lvl _             -> tv_lvl-          RuntimeUnk                    -> topTcLevel---tcTypeLevel :: TcType -> TcLevel--- Max level of any free var of the type-tcTypeLevel ty-  = foldDVarSet add topTcLevel (tyCoVarsOfTypeDSet ty)-  where-    add v lvl-      | isTcTyVar v = lvl `maxTcLevel` tcTyVarLevel v-      | otherwise = lvl--instance Outputable TcLevel where-  ppr (TcLevel us) = ppr us--promoteSkolem :: TcLevel -> TcTyVar -> TcTyVar-promoteSkolem tclvl skol-  | tclvl < tcTyVarLevel skol-  = ASSERT( isTcTyVar skol && isSkolemTyVar skol )-    setTcTyVarDetails skol (SkolemTv tclvl (isOverlappableTyVar skol))--  | otherwise-  = skol---- | Change the TcLevel in a skolem, extending a substitution-promoteSkolemX :: TcLevel -> TCvSubst -> TcTyVar -> (TCvSubst, TcTyVar)-promoteSkolemX tclvl subst skol-  = ASSERT( isTcTyVar skol && isSkolemTyVar skol )-    (new_subst, new_skol)-  where-    new_skol-      | tclvl < tcTyVarLevel skol-      = setTcTyVarDetails (updateTyVarKind (substTy subst) skol)-                          (SkolemTv tclvl (isOverlappableTyVar skol))-      | otherwise-      = updateTyVarKind (substTy subst) skol-    new_subst = extendTvSubstWithClone subst skol new_skol--promoteSkolemsX :: TcLevel -> TCvSubst -> [TcTyVar] -> (TCvSubst, [TcTyVar])-promoteSkolemsX tclvl = mapAccumL (promoteSkolemX tclvl)--{- *********************************************************************-*                                                                      *-    Finding type family instances-*                                                                      *-************************************************************************--}---- | Finds outermost type-family applications occurring in a type,--- after expanding synonyms.  In the list (F, tys) that is returned--- we guarantee that tys matches F's arity.  For example, given---    type family F a :: * -> *    (arity 1)--- calling tcTyFamInsts on (Maybe (F Int Bool) will return---     (F, [Int]), not (F, [Int,Bool])------ This is important for its use in deciding termination of type--- instances (see #11581).  E.g.---    type instance G [Int] = ...(F Int <big type>)...--- we don't need to take <big type> into account when asking if--- the calls on the RHS are smaller than the LHS-tcTyFamInsts :: Type -> [(TyCon, [Type])]-tcTyFamInsts = map (\(_,b,c) -> (b,c)) . tcTyFamInstsAndVis---- | Like 'tcTyFamInsts', except that the output records whether the--- type family and its arguments occur as an /invisible/ argument in--- some type application. This information is useful because it helps GHC know--- when to turn on @-fprint-explicit-kinds@ during error reporting so that--- users can actually see the type family being mentioned.------ As an example, consider:------ @--- class C a--- data T (a :: k)--- type family F a :: k--- instance C (T @(F Int) (F Bool))--- @------ There are two occurrences of the type family `F` in that `C` instance, so--- @'tcTyFamInstsAndVis' (C (T \@(F Int) (F Bool)))@ will return:------ @--- [ ('True',  F, [Int])--- , ('False', F, [Bool]) ]--- @------ @F Int@ is paired with 'True' since it appears as an /invisible/ argument--- to @C@, whereas @F Bool@ is paired with 'False' since it appears an a--- /visible/ argument to @C@.------ See also @Note [Kind arguments in error messages]@ in "TcErrors".-tcTyFamInstsAndVis :: Type -> [(Bool, TyCon, [Type])]-tcTyFamInstsAndVis = tcTyFamInstsAndVisX False--tcTyFamInstsAndVisX-  :: Bool -- ^ Is this an invisible argument to some type application?-  -> Type -> [(Bool, TyCon, [Type])]-tcTyFamInstsAndVisX = go-  where-    go is_invis_arg ty-      | Just exp_ty <- tcView ty       = go is_invis_arg exp_ty-    go _ (TyVarTy _)                   = []-    go is_invis_arg (TyConApp tc tys)-      | isTypeFamilyTyCon tc-      = [(is_invis_arg, tc, take (tyConArity tc) tys)]-      | otherwise-      = tcTyConAppTyFamInstsAndVisX is_invis_arg tc tys-    go _            (LitTy {})         = []-    go is_invis_arg (ForAllTy bndr ty) = go is_invis_arg (binderType bndr)-                                         ++ go is_invis_arg ty-    go is_invis_arg (FunTy _ ty1 ty2)  = go is_invis_arg ty1-                                         ++ go is_invis_arg ty2-    go is_invis_arg ty@(AppTy _ _)     =-      let (ty_head, ty_args) = splitAppTys ty-          ty_arg_flags       = appTyArgFlags ty_head ty_args-      in go is_invis_arg ty_head-         ++ concat (zipWith (\flag -> go (isInvisibleArgFlag flag))-                            ty_arg_flags ty_args)-    go is_invis_arg (CastTy ty _)      = go is_invis_arg ty-    go _            (CoercionTy _)     = [] -- don't count tyfams in coercions,-                                            -- as they never get normalized,-                                            -- anyway---- | In an application of a 'TyCon' to some arguments, find the outermost--- occurrences of type family applications within the arguments. This function--- will not consider the 'TyCon' itself when checking for type family--- applications.------ See 'tcTyFamInstsAndVis' for more details on how this works (as this--- function is called inside of 'tcTyFamInstsAndVis').-tcTyConAppTyFamInstsAndVis :: TyCon -> [Type] -> [(Bool, TyCon, [Type])]-tcTyConAppTyFamInstsAndVis = tcTyConAppTyFamInstsAndVisX False--tcTyConAppTyFamInstsAndVisX-  :: Bool -- ^ Is this an invisible argument to some type application?-  -> TyCon -> [Type] -> [(Bool, TyCon, [Type])]-tcTyConAppTyFamInstsAndVisX is_invis_arg tc tys =-  let (invis_tys, vis_tys) = partitionInvisibleTypes tc tys-  in concat $ map (tcTyFamInstsAndVisX True)         invis_tys-           ++ map (tcTyFamInstsAndVisX is_invis_arg) vis_tys--isTyFamFree :: Type -> Bool--- ^ Check that a type does not contain any type family applications.-isTyFamFree = null . tcTyFamInsts--anyRewritableTyVar :: Bool    -- Ignore casts and coercions-                   -> EqRel   -- Ambient role-                   -> (EqRel -> TcTyVar -> Bool)-                   -> TcType -> Bool--- (anyRewritableTyVar ignore_cos pred ty) returns True---    if the 'pred' returns True of any free TyVar in 'ty'--- Do not look inside casts and coercions if 'ignore_cos' is True--- See Note [anyRewritableTyVar must be role-aware]-anyRewritableTyVar ignore_cos role pred ty-  = go role emptyVarSet ty-  where-    -- NB: No need to expand synonyms, because we can find-    -- all free variables of a synonym by looking at its-    -- arguments--    go_tv rl bvs tv | tv `elemVarSet` bvs = False-                    | otherwise           = pred rl tv--    go rl bvs (TyVarTy tv)       = go_tv rl bvs tv-    go _ _     (LitTy {})        = False-    go rl bvs (TyConApp tc tys)  = go_tc rl bvs tc tys-    go rl bvs (AppTy fun arg)    = go rl bvs fun || go NomEq bvs arg-    go rl bvs (FunTy _ arg res)  = go NomEq bvs arg_rep || go NomEq bvs res_rep ||-                                   go rl bvs arg || go rl bvs res-      where arg_rep = getRuntimeRep arg -- forgetting these causes #17024-            res_rep = getRuntimeRep res-    go rl bvs (ForAllTy tv ty)   = go rl (bvs `extendVarSet` binderVar tv) ty-    go rl bvs (CastTy ty co)     = go rl bvs ty || go_co rl bvs co-    go rl bvs (CoercionTy co)    = go_co rl bvs co  -- ToDo: check--    go_tc NomEq  bvs _  tys = any (go NomEq bvs) tys-    go_tc ReprEq bvs tc tys = any (go_arg bvs)-                              (tyConRolesRepresentational tc `zip` tys)--    go_arg bvs (Nominal,          ty) = go NomEq  bvs ty-    go_arg bvs (Representational, ty) = go ReprEq bvs ty-    go_arg _   (Phantom,          _)  = False  -- We never rewrite with phantoms--    go_co rl bvs co-      | ignore_cos = False-      | otherwise  = anyVarSet (go_tv rl bvs) (tyCoVarsOfCo co)-      -- We don't have an equivalent of anyRewritableTyVar for coercions-      -- (at least not yet) so take the free vars and test them--{- Note [anyRewritableTyVar must be role-aware]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-anyRewritableTyVar is used during kick-out from the inert set,-to decide if, given a new equality (a ~ ty), we should kick out-a constraint C.  Rather than gather free variables and see if 'a'-is among them, we instead pass in a predicate; this is just efficiency.--Moreover, consider-  work item:   [G] a ~R f b-  inert item:  [G] b ~R f a-We use anyRewritableTyVar to decide whether to kick out the inert item,-on the grounds that the work item might rewrite it. Well, 'a' is certainly-free in [G] b ~R f a.  But because the role of a type variable ('f' in-this case) is nominal, the work item can't actually rewrite the inert item.-Moreover, if we were to kick out the inert item the exact same situation-would re-occur and we end up with an infinite loop in which each kicks-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, not in GHC.Core.TyCo.FVs,-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--{--************************************************************************-*                                                                      *-                Predicates-*                                                                      *-************************************************************************--}--tcIsTcTyVar :: TcTyVar -> Bool--- See Note [TcTyVars and TyVars in the typechecker]-tcIsTcTyVar tv = isTyVar tv--isTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool-isTouchableMetaTyVar ctxt_tclvl tv-  | isTyVar tv -- See Note [Coercion variables in free variable lists]-  , MetaTv { mtv_tclvl = tv_tclvl, mtv_info = info } <- tcTyVarDetails tv-  , not (isFlattenInfo info)-  = ASSERT2( checkTcLevelInvariant ctxt_tclvl tv_tclvl,-             ppr tv $$ ppr tv_tclvl $$ ppr ctxt_tclvl )-    tv_tclvl `sameDepthAs` ctxt_tclvl--  | otherwise = False--isFloatedTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool-isFloatedTouchableMetaTyVar ctxt_tclvl tv-  | isTyVar tv -- See Note [Coercion variables in free variable lists]-  , MetaTv { mtv_tclvl = tv_tclvl, mtv_info = info } <- tcTyVarDetails tv-  , not (isFlattenInfo info)-  = tv_tclvl `strictlyDeeperThan` ctxt_tclvl--  | otherwise = False--isImmutableTyVar :: TyVar -> Bool-isImmutableTyVar tv = isSkolemTyVar tv--isTyConableTyVar, isSkolemTyVar, isOverlappableTyVar,-  isMetaTyVar, isAmbiguousTyVar,-  isFmvTyVar, isFskTyVar, isFlattenTyVar :: TcTyVar -> Bool--isTyConableTyVar tv-        -- True of a meta-type variable that can be filled in-        -- with a type constructor application; in particular,-        -- not a TyVarTv-  | isTyVar tv -- See Note [Coercion variables in free variable lists]-  = case tcTyVarDetails tv of-        MetaTv { mtv_info = TyVarTv } -> False-        _                             -> True-  | otherwise = True--isFmvTyVar tv-  = ASSERT2( tcIsTcTyVar tv, ppr tv )-    case tcTyVarDetails tv of-        MetaTv { mtv_info = FlatMetaTv } -> True-        _                                -> False--isFskTyVar tv-  = ASSERT2( tcIsTcTyVar tv, ppr tv )-    case tcTyVarDetails tv of-        MetaTv { mtv_info = FlatSkolTv } -> True-        _                                -> False---- | True of both given and wanted flatten-skolems (fmv and fsk)-isFlattenTyVar tv-  = ASSERT2( tcIsTcTyVar tv, ppr tv )-    case tcTyVarDetails tv of-        MetaTv { mtv_info = info } -> isFlattenInfo info-        _                          -> False--isSkolemTyVar tv-  = ASSERT2( tcIsTcTyVar tv, ppr tv )-    case tcTyVarDetails tv of-        MetaTv {} -> False-        _other    -> True--isOverlappableTyVar tv-  | isTyVar tv -- See Note [Coercion variables in free variable lists]-  = case tcTyVarDetails tv of-        SkolemTv _ overlappable -> overlappable-        _                       -> False-  | otherwise = False--isMetaTyVar tv-  | isTyVar tv -- See Note [Coercion variables in free variable lists]-  = case tcTyVarDetails tv of-        MetaTv {} -> True-        _         -> False-  | otherwise = False---- 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--- 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]-  = case tcTyVarDetails tv of-        MetaTv {}     -> True-        RuntimeUnk {} -> True-        _             -> False-  | otherwise = False--isMetaTyVarTy :: TcType -> Bool-isMetaTyVarTy (TyVarTy tv) = isMetaTyVar tv-isMetaTyVarTy _            = False--metaTyVarInfo :: TcTyVar -> MetaInfo-metaTyVarInfo tv-  = case tcTyVarDetails tv of-      MetaTv { mtv_info = info } -> info-      _ -> pprPanic "metaTyVarInfo" (ppr tv)--isFlattenInfo :: MetaInfo -> Bool-isFlattenInfo FlatMetaTv = True-isFlattenInfo FlatSkolTv = True-isFlattenInfo _          = False--metaTyVarTcLevel :: TcTyVar -> TcLevel-metaTyVarTcLevel tv-  = case tcTyVarDetails tv of-      MetaTv { mtv_tclvl = tclvl } -> tclvl-      _ -> pprPanic "metaTyVarTcLevel" (ppr tv)--metaTyVarTcLevel_maybe :: TcTyVar -> Maybe TcLevel-metaTyVarTcLevel_maybe tv-  = case tcTyVarDetails tv of-      MetaTv { mtv_tclvl = tclvl } -> Just tclvl-      _                            -> Nothing--metaTyVarRef :: TyVar -> IORef MetaDetails-metaTyVarRef tv-  = case tcTyVarDetails tv of-        MetaTv { mtv_ref = ref } -> ref-        _ -> pprPanic "metaTyVarRef" (ppr tv)--setMetaTyVarTcLevel :: TcTyVar -> TcLevel -> TcTyVar-setMetaTyVarTcLevel tv tclvl-  = case tcTyVarDetails tv of-      details@(MetaTv {}) -> setTcTyVarDetails tv (details { mtv_tclvl = tclvl })-      _ -> pprPanic "metaTyVarTcLevel" (ppr tv)--isTyVarTyVar :: Var -> Bool-isTyVarTyVar tv-  = case tcTyVarDetails tv of-        MetaTv { mtv_info = TyVarTv } -> True-        _                             -> False--isFlexi, isIndirect :: MetaDetails -> Bool-isFlexi Flexi = True-isFlexi _     = False--isIndirect (Indirect _) = True-isIndirect _            = False--isRuntimeUnkSkol :: TyVar -> Bool--- Called only in TcErrors; see Note [Runtime skolems] there-isRuntimeUnkSkol x-  | RuntimeUnk <- tcTyVarDetails x = True-  | otherwise                      = False--mkTyVarNamePairs :: [TyVar] -> [(Name,TyVar)]--- Just pair each TyVar with its own name-mkTyVarNamePairs tvs = [(tyVarName tv, tv) | tv <- tvs]--findDupTyVarTvs :: [(Name,TcTyVar)] -> [(Name,Name)]--- If we have [...(x1,tv)...(x2,tv)...]--- return (x1,x2) in the result list-findDupTyVarTvs prs-  = concatMap mk_result_prs $-    findDupsEq eq_snd prs-  where-    eq_snd (_,tv1) (_,tv2) = tv1 == tv2-    mk_result_prs ((n1,_) :| xs) = map (\(n2,_) -> (n1,n2)) xs--{--************************************************************************-*                                                                      *-\subsection{Tau, sigma and rho}-*                                                                      *-************************************************************************--}--mkSigmaTy :: [TyCoVarBinder] -> [PredType] -> Type -> Type-mkSigmaTy bndrs theta tau = mkForAllTys bndrs (mkPhiTy theta tau)---- | Make a sigma ty where all type variables are 'Inferred'. That is,--- they cannot be used with visible type application.-mkInfSigmaTy :: [TyCoVar] -> [PredType] -> Type -> Type-mkInfSigmaTy tyvars theta ty = mkSigmaTy (mkTyCoVarBinders Inferred tyvars) theta ty---- | Make a sigma ty where all type variables are "specified". That is,--- they can be used with visible type application-mkSpecSigmaTy :: [TyVar] -> [PredType] -> Type -> Type-mkSpecSigmaTy tyvars preds ty = mkSigmaTy (mkTyCoVarBinders Specified tyvars) preds ty--mkPhiTy :: [PredType] -> Type -> Type-mkPhiTy = mkInvisFunTys------------------getDFunTyKey :: Type -> OccName -- Get some string from a type, to be used to-                                -- construct a dictionary function name-getDFunTyKey ty | Just ty' <- coreView ty = getDFunTyKey ty'-getDFunTyKey (TyVarTy tv)            = getOccName tv-getDFunTyKey (TyConApp tc _)         = getOccName tc-getDFunTyKey (LitTy x)               = getDFunTyLitKey x-getDFunTyKey (AppTy fun _)           = getDFunTyKey fun-getDFunTyKey (FunTy {})              = getOccName funTyCon-getDFunTyKey (ForAllTy _ t)          = getDFunTyKey t-getDFunTyKey (CastTy ty _)           = getDFunTyKey ty-getDFunTyKey t@(CoercionTy _)        = pprPanic "getDFunTyKey" (ppr t)--getDFunTyLitKey :: TyLit -> OccName-getDFunTyLitKey (NumTyLit n) = mkOccName Name.varName (show n)-getDFunTyLitKey (StrTyLit n) = mkOccName Name.varName (show n)  -- hm--{- *********************************************************************-*                                                                      *-           Building types-*                                                                      *-********************************************************************* -}---- ToDo: I think we need Tc versions of these--- Reason: mkCastTy checks isReflexiveCastTy, which checks---         for equality; and that has a different answer---         depending on whether or not Type = Constraint--mkTcAppTys :: Type -> [Type] -> Type-mkTcAppTys = mkAppTys--mkTcAppTy :: Type -> Type -> Type-mkTcAppTy = mkAppTy--mkTcCastTy :: Type -> Coercion -> Type-mkTcCastTy = mkCastTy   -- Do we need a tc version of mkCastTy?--{--************************************************************************-*                                                                      *-\subsection{Expanding and splitting}-*                                                                      *-************************************************************************--These tcSplit functions are like their non-Tc analogues, but-        *) they do not look through newtypes--However, they are non-monadic and do not follow through mutable type-variables.  It's up to you to make sure this doesn't matter.--}---- | Splits a forall type into a list of 'TyBinder's and the inner type.--- Always succeeds, even if it returns an empty list.-tcSplitPiTys :: Type -> ([TyBinder], Type)-tcSplitPiTys ty-  = ASSERT( all isTyBinder (fst sty) ) sty-  where sty = splitPiTys ty---- | Splits a type into a TyBinder and a body, if possible. Panics otherwise-tcSplitPiTy_maybe :: Type -> Maybe (TyBinder, Type)-tcSplitPiTy_maybe ty-  = ASSERT( isMaybeTyBinder sty ) sty-  where-    sty = splitPiTy_maybe ty-    isMaybeTyBinder (Just (t,_)) = isTyBinder t-    isMaybeTyBinder _            = True--tcSplitForAllTy_maybe :: Type -> Maybe (TyVarBinder, Type)-tcSplitForAllTy_maybe ty | Just ty' <- tcView ty = tcSplitForAllTy_maybe ty'-tcSplitForAllTy_maybe (ForAllTy tv ty) = ASSERT( isTyVarBinder tv ) Just (tv, ty)-tcSplitForAllTy_maybe _                = Nothing---- | Like 'tcSplitPiTys', but splits off only named binders,--- returning just the tycovars.-tcSplitForAllTys :: Type -> ([TyVar], Type)-tcSplitForAllTys ty-  = ASSERT( all isTyVar (fst sty) ) sty-  where sty = splitForAllTys ty---- | Like 'tcSplitForAllTys', but only splits a 'ForAllTy' if--- @'sameVis' argf supplied_argf@ is 'True', where @argf@ is the visibility--- of the @ForAllTy@'s binder and @supplied_argf@ is the visibility provided--- as an argument to this function.-tcSplitForAllTysSameVis :: ArgFlag -> Type -> ([TyVar], Type)-tcSplitForAllTysSameVis supplied_argf ty = ASSERT( all isTyVar (fst sty) ) sty-  where sty = splitForAllTysSameVis supplied_argf ty---- | Like 'tcSplitForAllTys', but splits off only named binders.-tcSplitForAllVarBndrs :: Type -> ([TyVarBinder], Type)-tcSplitForAllVarBndrs ty = ASSERT( all isTyVarBinder (fst sty)) sty-  where sty = splitForAllVarBndrs ty---- | Is this a ForAllTy with a named binder?-tcIsForAllTy :: Type -> Bool-tcIsForAllTy ty | Just ty' <- tcView ty = tcIsForAllTy ty'-tcIsForAllTy (ForAllTy {}) = True-tcIsForAllTy _             = False--tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)--- Split off the first predicate argument from a type-tcSplitPredFunTy_maybe ty-  | Just ty' <- tcView ty = tcSplitPredFunTy_maybe ty'-tcSplitPredFunTy_maybe (FunTy { ft_af = InvisArg-                              , ft_arg = arg, ft_res = res })-  = Just (arg, res)-tcSplitPredFunTy_maybe _-  = Nothing--tcSplitPhiTy :: Type -> (ThetaType, Type)-tcSplitPhiTy ty-  = split ty []-  where-    split ty ts-      = case tcSplitPredFunTy_maybe ty of-          Just (pred, ty) -> split ty (pred:ts)-          Nothing         -> (reverse ts, ty)---- | Split a sigma type into its parts.-tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)-tcSplitSigmaTy ty = case tcSplitForAllTys ty of-                        (tvs, rho) -> case tcSplitPhiTy rho of-                                        (theta, tau) -> (tvs, theta, tau)---- | Split a sigma type into its parts, going underneath as many @ForAllTy@s--- as possible. For example, given this type synonym:------ @--- type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t--- @------ if you called @tcSplitSigmaTy@ on this type:------ @--- forall s t a b. Each s t a b => Traversal s t a b--- @------ then it would return @([s,t,a,b], [Each s t a b], Traversal s t a b)@. But--- if you instead called @tcSplitNestedSigmaTys@ on the type, it would return--- @([s,t,a,b,f], [Each s t a b, Applicative f], (a -> f b) -> s -> f t)@.-tcSplitNestedSigmaTys :: Type -> ([TyVar], ThetaType, Type)--- NB: This is basically a pure version of deeplyInstantiate (from Inst) that--- doesn't compute an HsWrapper.-tcSplitNestedSigmaTys ty-    -- If there's a forall, split it apart and try splitting the rho type-    -- underneath it.-  | Just (arg_tys, tvs1, theta1, rho1) <- tcDeepSplitSigmaTy_maybe ty-  = let (tvs2, theta2, rho2) = tcSplitNestedSigmaTys rho1-    in (tvs1 ++ tvs2, theta1 ++ theta2, mkVisFunTys arg_tys rho2)-    -- If there's no forall, we're done.-  | otherwise = ([], [], ty)--------------------------tcDeepSplitSigmaTy_maybe-  :: TcSigmaType -> Maybe ([TcType], [TyVar], ThetaType, TcSigmaType)--- Looks for a *non-trivial* quantified type, under zero or more function arrows--- By "non-trivial" we mean either tyvars or constraints are non-empty--tcDeepSplitSigmaTy_maybe ty-  | Just (arg_ty, res_ty)           <- tcSplitFunTy_maybe ty-  , Just (arg_tys, tvs, theta, rho) <- tcDeepSplitSigmaTy_maybe res_ty-  = Just (arg_ty:arg_tys, tvs, theta, rho)--  | (tvs, theta, rho) <- tcSplitSigmaTy ty-  , not (null tvs && null theta)-  = Just ([], tvs, theta, rho)--  | otherwise = Nothing--------------------------tcTyConAppTyCon :: Type -> TyCon-tcTyConAppTyCon ty-  = case tcTyConAppTyCon_maybe ty of-      Just tc -> tc-      Nothing -> pprPanic "tcTyConAppTyCon" (pprType ty)---- | Like 'tcRepSplitTyConApp_maybe', but only returns the 'TyCon'.-tcTyConAppTyCon_maybe :: Type -> Maybe TyCon-tcTyConAppTyCon_maybe ty-  | Just ty' <- tcView ty = tcTyConAppTyCon_maybe ty'-tcTyConAppTyCon_maybe (TyConApp tc _)-  = Just tc-tcTyConAppTyCon_maybe (FunTy { ft_af = VisArg })-  = Just funTyCon  -- (=>) is /not/ a TyCon in its own right-                   -- C.f. tcRepSplitAppTy_maybe-tcTyConAppTyCon_maybe _-  = Nothing--tcTyConAppArgs :: Type -> [Type]-tcTyConAppArgs ty = case tcSplitTyConApp_maybe ty of-                        Just (_, args) -> args-                        Nothing        -> pprPanic "tcTyConAppArgs" (pprType ty)--tcSplitTyConApp :: Type -> (TyCon, [Type])-tcSplitTyConApp ty = case tcSplitTyConApp_maybe ty of-                        Just stuff -> stuff-                        Nothing    -> pprPanic "tcSplitTyConApp" (pprType ty)--------------------------tcSplitFunTys :: Type -> ([Type], Type)-tcSplitFunTys ty = case tcSplitFunTy_maybe ty of-                        Nothing        -> ([], ty)-                        Just (arg,res) -> (arg:args, res')-                                       where-                                          (args,res') = tcSplitFunTys res--tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)-tcSplitFunTy_maybe ty-  | Just ty' <- tcView ty = tcSplitFunTy_maybe ty'-tcSplitFunTy_maybe (FunTy { ft_af = af, ft_arg = arg, ft_res = res })-  | VisArg <- af = Just (arg, res)-tcSplitFunTy_maybe _ = Nothing-        -- Note the VisArg guard-        -- Consider     (?x::Int) => Bool-        -- We don't want to treat this as a function type!-        -- A concrete example is test tc230:-        --      f :: () -> (?p :: ()) => () -> ()-        ---        --      g = f () ()--tcSplitFunTysN :: Arity                      -- n: Number of desired args-               -> TcRhoType-               -> Either Arity               -- Number of missing arrows-                        ([TcSigmaType],      -- Arg types (always N types)-                         TcSigmaType)        -- The rest of the type--- ^ Split off exactly the specified number argument types--- Returns---  (Left m) if there are 'm' missing arrows in the type---  (Right (tys,res)) if the type looks like t1 -> ... -> tn -> res-tcSplitFunTysN n ty- | n == 0- = Right ([], ty)- | Just (arg,res) <- tcSplitFunTy_maybe ty- = case tcSplitFunTysN (n-1) res of-     Left m            -> Left m-     Right (args,body) -> Right (arg:args, body)- | otherwise- = Left n--tcSplitFunTy :: Type -> (Type, Type)-tcSplitFunTy  ty = expectJust "tcSplitFunTy" (tcSplitFunTy_maybe ty)--tcFunArgTy :: Type -> Type-tcFunArgTy    ty = fst (tcSplitFunTy ty)--tcFunResultTy :: Type -> Type-tcFunResultTy ty = snd (tcSplitFunTy ty)---- | Strips off n *visible* arguments and returns the resulting type-tcFunResultTyN :: HasDebugCallStack => Arity -> Type -> Type-tcFunResultTyN n ty-  | Right (_, res_ty) <- tcSplitFunTysN n ty-  = res_ty-  | otherwise-  = pprPanic "tcFunResultTyN" (ppr n <+> ppr ty)--------------------------tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)-tcSplitAppTy_maybe ty | Just ty' <- tcView ty = tcSplitAppTy_maybe ty'-tcSplitAppTy_maybe ty = tcRepSplitAppTy_maybe ty--tcSplitAppTy :: Type -> (Type, Type)-tcSplitAppTy ty = case tcSplitAppTy_maybe ty of-                    Just stuff -> stuff-                    Nothing    -> pprPanic "tcSplitAppTy" (pprType ty)--tcSplitAppTys :: Type -> (Type, [Type])-tcSplitAppTys ty-  = go ty []-  where-    go ty args = case tcSplitAppTy_maybe ty of-                   Just (ty', arg) -> go ty' (arg:args)-                   Nothing         -> (ty,args)---- | Returns the number of arguments in the given type, without--- looking through synonyms. This is used only for error reporting.--- We don't look through synonyms because of #11313.-tcRepGetNumAppTys :: Type -> Arity-tcRepGetNumAppTys = length . snd . repSplitAppTys---------------------------- | If the type is a tyvar, possibly under a cast, returns it, along--- with the coercion. Thus, the co is :: kind tv ~N kind type-tcGetCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)-tcGetCastedTyVar_maybe ty | Just ty' <- tcView ty = tcGetCastedTyVar_maybe ty'-tcGetCastedTyVar_maybe (CastTy (TyVarTy tv) co) = Just (tv, co)-tcGetCastedTyVar_maybe (TyVarTy tv)             = Just (tv, mkNomReflCo (tyVarKind tv))-tcGetCastedTyVar_maybe _                        = Nothing--tcGetTyVar_maybe :: Type -> Maybe TyVar-tcGetTyVar_maybe ty | Just ty' <- tcView ty = tcGetTyVar_maybe ty'-tcGetTyVar_maybe (TyVarTy tv)   = Just tv-tcGetTyVar_maybe _              = Nothing--tcGetTyVar :: String -> Type -> TyVar-tcGetTyVar msg ty-  = case tcGetTyVar_maybe ty of-     Just tv -> tv-     Nothing -> pprPanic msg (ppr ty)--tcIsTyVarTy :: Type -> Bool-tcIsTyVarTy ty | Just ty' <- tcView ty = tcIsTyVarTy ty'-tcIsTyVarTy (CastTy ty _) = tcIsTyVarTy ty  -- look through casts, as-                                            -- this is only used for-                                            -- e.g., FlexibleContexts-tcIsTyVarTy (TyVarTy _)   = True-tcIsTyVarTy _             = False--------------------------tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type])--- Split the type of a dictionary function--- We don't use tcSplitSigmaTy,  because a DFun may (with NDP)--- have non-Pred arguments, such as---     df :: forall m. (forall b. Eq b => Eq (m b)) -> C m------ Also NB splitFunTys, not tcSplitFunTys;--- the latter specifically stops at PredTy arguments,--- and we don't want to do that here-tcSplitDFunTy ty-  = case tcSplitForAllTys ty   of { (tvs, rho)    ->-    case splitFunTys rho       of { (theta, tau)  ->-    case tcSplitDFunHead tau   of { (clas, tys)   ->-    (tvs, theta, clas, tys) }}}--tcSplitDFunHead :: Type -> (Class, [Type])-tcSplitDFunHead = getClassPredTys--tcSplitMethodTy :: Type -> ([TyVar], PredType, Type)--- A class method (selector) always has a type like---   forall as. C as => blah--- So if the class looks like---   class C a where---     op :: forall b. (Eq a, Ix b) => a -> b--- the class method type looks like---  op :: forall a. C a => forall b. (Eq a, Ix b) => a -> b------ tcSplitMethodTy just peels off the outer forall and--- that first predicate-tcSplitMethodTy ty-  | (sel_tyvars,sel_rho) <- tcSplitForAllTys ty-  , Just (first_pred, local_meth_ty) <- tcSplitPredFunTy_maybe sel_rho-  = (sel_tyvars, first_pred, local_meth_ty)-  | otherwise-  = pprPanic "tcSplitMethodTy" (ppr ty)---{- *********************************************************************-*                                                                      *-            Type equalities-*                                                                      *-********************************************************************* -}--tcEqKind :: HasDebugCallStack => TcKind -> TcKind -> Bool-tcEqKind = tcEqType--tcEqType :: HasDebugCallStack => TcType -> TcType -> Bool--- tcEqType is a proper implements the same Note [Non-trivial definitional--- equality] (in GHC.Core.TyCo.Rep) as `eqType`, but Type.eqType believes (* ==--- Constraint), and that is NOT what we want in the type checker!-tcEqType ty1 ty2-  =  tc_eq_type False False ki1 ki2-  && tc_eq_type False False ty1 ty2-  where-    ki1 = tcTypeKind ty1-    ki2 = tcTypeKind ty2---- | Just like 'tcEqType', but will return True for types of different kinds--- as long as their non-coercion structure is identical.-tcEqTypeNoKindCheck :: TcType -> TcType -> Bool-tcEqTypeNoKindCheck ty1 ty2-  = tc_eq_type False False ty1 ty2---- | Like 'tcEqType', but returns True if the /visible/ part of the types--- are equal, even if they are really unequal (in the invisible bits)-tcEqTypeVis :: TcType -> TcType -> Bool-tcEqTypeVis ty1 ty2 = tc_eq_type False True ty1 ty2---- | Like 'pickyEqTypeVis', but returns a Bool for convenience-pickyEqType :: TcType -> TcType -> Bool--- Check when two types _look_ the same, _including_ synonyms.--- So (pickyEqType String [Char]) returns False--- This ignores kinds and coercions, because this is used only for printing.-pickyEqType ty1 ty2 = tc_eq_type True False ty1 ty2------ | Real worker for 'tcEqType'. No kind check!-tc_eq_type :: Bool          -- ^ True <=> do not expand type synonyms-           -> Bool          -- ^ True <=> compare visible args only-           -> Type -> Type-           -> Bool--- Flags False, False is the usual setting for tc_eq_type-tc_eq_type keep_syns vis_only orig_ty1 orig_ty2-  = go orig_env orig_ty1 orig_ty2-  where-    go :: RnEnv2 -> Type -> Type -> Bool-    go env t1 t2 | not keep_syns, Just t1' <- tcView t1 = go env t1' t2-    go env t1 t2 | not keep_syns, Just t2' <- tcView t2 = go env t1 t2'--    go env (TyVarTy tv1) (TyVarTy tv2)-      = rnOccL env tv1 == rnOccR env tv2--    go _   (LitTy lit1) (LitTy lit2)-      = lit1 == lit2--    go env (ForAllTy (Bndr tv1 vis1) ty1)-           (ForAllTy (Bndr tv2 vis2) ty2)-      =  vis1 == vis2-      && (vis_only || go env (varType tv1) (varType tv2))-      && go (rnBndr2 env tv1 tv2) ty1 ty2--    -- Make sure we handle all FunTy cases since falling through to the-    -- AppTy case means that tcRepSplitAppTy_maybe may see an unzonked-    -- kind variable, which causes things to blow up.-    go env (FunTy _ arg1 res1) (FunTy _ arg2 res2)-      = go env arg1 arg2 && go env res1 res2-    go env ty (FunTy _ arg res) = eqFunTy env arg res ty-    go env (FunTy _ arg res) ty = eqFunTy env arg res ty--      -- See Note [Equality on AppTys] in GHC.Core.Type-    go env (AppTy s1 t1)        ty2-      | Just (s2, t2) <- tcRepSplitAppTy_maybe ty2-      = go env s1 s2 && go env t1 t2-    go env ty1                  (AppTy s2 t2)-      | Just (s1, t1) <- tcRepSplitAppTy_maybe ty1-      = go env s1 s2 && go env t1 t2--    go env (TyConApp tc1 ts1)   (TyConApp tc2 ts2)-      = tc1 == tc2 && gos env (tc_vis tc1) ts1 ts2--    go env (CastTy t1 _)   t2              = go env t1 t2-    go env t1              (CastTy t2 _)   = go env t1 t2-    go _   (CoercionTy {}) (CoercionTy {}) = True--    go _ _ _ = False--    gos _   _         []       []      = True-    gos env (ig:igs) (t1:ts1) (t2:ts2) = (ig || go env t1 t2)-                                      && gos env igs ts1 ts2-    gos _ _ _ _ = False--    tc_vis :: TyCon -> [Bool]  -- True for the fields we should ignore-    tc_vis tc | vis_only  = inviss ++ repeat False    -- Ignore invisibles-              | otherwise = repeat False              -- Ignore nothing-       -- The repeat False is necessary because tycons-       -- can legitimately be oversaturated-      where-        bndrs = tyConBinders tc-        inviss  = map isInvisibleTyConBinder bndrs--    orig_env = mkRnEnv2 $ mkInScopeSet $ tyCoVarsOfTypes [orig_ty1, orig_ty2]--    -- @eqFunTy arg res ty@ is True when @ty@ equals @FunTy arg res@. This is-    -- sometimes hard to know directly because @ty@ might have some casts-    -- obscuring the FunTy. And 'splitAppTy' is difficult because we can't-    -- always extract a RuntimeRep (see Note [xyz]) if the kind of the arg or-    -- res is unzonked/unflattened. Thus this function, which handles this-    -- corner case.-    eqFunTy :: RnEnv2 -> Type -> Type -> Type -> Bool-               -- Last arg is /not/ FunTy-    eqFunTy env arg res ty@(AppTy{}) = get_args ty []-      where-        get_args :: Type -> [Type] -> Bool-        get_args (AppTy f x)       args = get_args f (x:args)-        get_args (CastTy t _)      args = get_args t args-        get_args (TyConApp tc tys) args-          | tc == funTyCon-          , [_, _, arg', res'] <- tys ++ args-          = go env arg arg' && go env res res'-        get_args _ _    = False-    eqFunTy _ _ _ _     = False--{- *********************************************************************-*                                                                      *-                       Predicate types-*                                                                      *-************************************************************************--Deconstructors and tests on predicate types--Note [Kind polymorphic type classes]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-    class C f where...   -- C :: forall k. k -> Constraint-    g :: forall (f::*). C f => f -> f--Here the (C f) in the signature is really (C * f), and we-don't want to complain that the * isn't a type variable!--}--isTyVarClassPred :: PredType -> Bool-isTyVarClassPred ty = case getClassPredTys_maybe ty of-    Just (_, tys) -> all isTyVarTy tys-    _             -> False----------------------------checkValidClsArgs :: Bool -> Class -> [KindOrType] -> Bool--- If the Bool is True (flexible contexts), return True (i.e. ok)--- Otherwise, check that the type (not kind) args are all headed by a tyvar---   E.g. (Eq a) accepted, (Eq (f a)) accepted, but (Eq Int) rejected--- This function is here rather than in TcValidity because it is--- called from TcSimplify, which itself is imported by TcValidity-checkValidClsArgs flexible_contexts cls kts-  | flexible_contexts = True-  | otherwise         = all hasTyVarHead tys-  where-    tys = filterOutInvisibleTypes (classTyCon cls) kts--hasTyVarHead :: Type -> Bool--- Returns true of (a t1 .. tn), where 'a' is a type variable-hasTyVarHead ty                 -- Haskell 98 allows predicates of form-  | tcIsTyVarTy ty = True       --      C (a ty1 .. tyn)-  | otherwise                   -- where a is a type variable-  = case tcSplitAppTy_maybe ty of-       Just (ty, _) -> hasTyVarHead ty-       Nothing      -> False--evVarPred :: EvVar -> PredType-evVarPred var = varType var-  -- Historical note: I used to have an ASSERT here,-  -- checking (isEvVarType (varType var)).  But with something like-  --   f :: c => _ -> _-  -- we end up with (c :: kappa), and (kappa ~ Constraint).  Until-  -- we solve and zonk (which there is no particular reason to do for-  -- partial signatures, (isEvVarType kappa) will return False. But-  -- nothing is wrong.  So I just removed the ASSERT.----------------------- | When inferring types, should we quantify over a given predicate?--- Generally true of classes; generally false of equality constraints.--- Equality constraints that mention quantified type variables and--- implicit variables complicate the story. See Notes--- [Inheriting implicit parameters] and [Quantifying over equality constraints]-pickQuantifiablePreds-  :: TyVarSet           -- Quantifying over these-  -> TcThetaType        -- Proposed constraints to quantify-  -> TcThetaType        -- A subset that we can actually quantify--- This function decides whether a particular constraint should be--- quantified over, given the type variables that are being quantified-pickQuantifiablePreds qtvs theta-  = let flex_ctxt = True in  -- Quantify over non-tyvar constraints, even without-                             -- -XFlexibleContexts: see #10608, #10351-         -- flex_ctxt <- xoptM Opt_FlexibleContexts-    mapMaybe (pick_me flex_ctxt) theta-  where-    pick_me flex_ctxt pred-      = case classifyPredType pred of--          ClassPred cls tys-            | Just {} <- isCallStackPred cls tys-              -- NEVER infer a CallStack constraint.  Otherwise we let-              -- the constraints bubble up to be solved from the outer-              -- context, or be defaulted when we reach the top-level.-              -- See Note [Overview of implicit CallStacks]-            -> Nothing--            | isIPClass cls-            -> Just pred -- See note [Inheriting implicit parameters]--            | pick_cls_pred flex_ctxt cls tys-            -> Just pred--          EqPred eq_rel ty1 ty2-            | quantify_equality eq_rel ty1 ty2-            , Just (cls, tys) <- boxEqPred eq_rel ty1 ty2-              -- boxEqPred: See Note [Lift equality constraints when quantifying]-            , pick_cls_pred flex_ctxt cls tys-            -> Just (mkClassPred cls tys)--          IrredPred ty-            | tyCoVarsOfType ty `intersectsVarSet` qtvs-            -> Just pred--          _ -> Nothing---    pick_cls_pred flex_ctxt cls tys-      = tyCoVarsOfTypes tys `intersectsVarSet` qtvs-        && (checkValidClsArgs flex_ctxt cls tys)-           -- Only quantify over predicates that checkValidType-           -- will pass!  See #10351.--    -- See Note [Quantifying over equality constraints]-    quantify_equality NomEq  ty1 ty2 = quant_fun ty1 || quant_fun ty2-    quantify_equality ReprEq _   _   = True--    quant_fun ty-      = case tcSplitTyConApp_maybe ty of-          Just (tc, tys) | isTypeFamilyTyCon tc-                         -> tyCoVarsOfTypes tys `intersectsVarSet` qtvs-          _ -> False--boxEqPred :: EqRel -> Type -> Type -> Maybe (Class, [Type])--- Given (t1 ~# t2) or (t1 ~R# t2) return the boxed version---       (t1 ~ t2)  or (t1 `Coercible` t2)-boxEqPred eq_rel ty1 ty2-  = case eq_rel of-      NomEq  | homo_kind -> Just (eqClass,        [k1,     ty1, ty2])-             | otherwise -> Just (heqClass,       [k1, k2, ty1, ty2])-      ReprEq | homo_kind -> Just (coercibleClass, [k1,     ty1, ty2])-             | otherwise -> Nothing -- Sigh: we do not have hererogeneous Coercible-                                    --       so we can't abstract over it-                                    -- Nothing fundamental: we could add it- where-   k1 = tcTypeKind ty1-   k2 = tcTypeKind ty2-   homo_kind = k1 `tcEqType` k2--pickCapturedPreds-  :: TyVarSet           -- Quantifying over these-  -> TcThetaType        -- Proposed constraints to quantify-  -> TcThetaType        -- A subset that we can actually quantify--- A simpler version of pickQuantifiablePreds, used to winnow down--- the inferred constraints of a group of bindings, into those for--- one particular identifier-pickCapturedPreds qtvs theta-  = filter captured theta-  where-    captured pred = isIPPred pred || (tyCoVarsOfType pred `intersectsVarSet` qtvs)----- Superclasses--type PredWithSCs a = (PredType, [PredType], a)--mkMinimalBySCs :: forall a. (a -> PredType) -> [a] -> [a]--- Remove predicates that------   - are the same as another predicate------   - can be deduced from another by superclasses,------   - are a reflexive equality (e.g  * ~ *)---     (see Note [Remove redundant provided dicts] in TcPatSyn)------ The result is a subset of the input.--- The 'a' is just paired up with the PredType;---   typically it might be a dictionary Id-mkMinimalBySCs get_pred xs = go preds_with_scs []- where-   preds_with_scs :: [PredWithSCs a]-   preds_with_scs = [ (pred, pred : transSuperClasses pred, x)-                    | x <- xs-                    , let pred = get_pred x ]--   go :: [PredWithSCs a]   -- Work list-      -> [PredWithSCs a]   -- Accumulating result-      -> [a]-   go [] min_preds-     = reverse (map thdOf3 min_preds)-       -- The 'reverse' isn't strictly necessary, but it-       -- means that the results are returned in the same-       -- order as the input, which is generally saner-   go (work_item@(p,_,_) : work_list) min_preds-     | EqPred _ t1 t2 <- classifyPredType p-     , t1 `tcEqType` t2   -- See TcPatSyn-                          -- Note [Remove redundant provided dicts]-     = go work_list min_preds-     | p `in_cloud` work_list || p `in_cloud` min_preds-     = go work_list min_preds-     | otherwise-     = go work_list (work_item : min_preds)--   in_cloud :: PredType -> [PredWithSCs a] -> Bool-   in_cloud p ps = or [ p `tcEqType` p' | (_, scs, _) <- ps, p' <- scs ]--transSuperClasses :: PredType -> [PredType]--- (transSuperClasses p) returns (p's superclasses) not including p--- Stop if you encounter the same class again--- See Note [Expanding superclasses]-transSuperClasses p-  = go emptyNameSet p-  where-    go :: NameSet -> PredType -> [PredType]-    go rec_clss p-       | ClassPred cls tys <- classifyPredType p-       , let cls_nm = className cls-       , not (cls_nm `elemNameSet` rec_clss)-       , let rec_clss' | isCTupleClass cls = rec_clss-                       | otherwise         = rec_clss `extendNameSet` cls_nm-       = [ p' | sc <- immSuperClasses cls tys-              , p'  <- sc : go rec_clss' sc ]-       | otherwise-       = []--immSuperClasses :: Class -> [Type] -> [PredType]-immSuperClasses cls tys-  = substTheta (zipTvSubst tyvars tys) sc_theta-  where-    (tyvars,sc_theta,_,_) = classBigSig cls--isImprovementPred :: PredType -> Bool--- Either it's an equality, or has some functional dependency-isImprovementPred ty-  = case classifyPredType ty of-      EqPred NomEq t1 t2 -> not (t1 `tcEqType` t2)-      EqPred ReprEq _ _  -> False-      ClassPred cls _    -> classHasFds cls-      IrredPred {}       -> True -- Might have equalities after reduction?-      ForAllPred {}      -> False---- | Is the equality---        a ~r ...a....--- definitely insoluble or not?---      a ~r Maybe a      -- Definitely insoluble---      a ~N ...(F a)...  -- Not definitely insoluble---                        -- Perhaps (F a) reduces to Int---      a ~R ...(N a)...  -- Not definitely insoluble---                        -- Perhaps newtype N a = MkN Int--- See Note [Occurs check error] in--- TcCanonical for the motivation for this function.-isInsolubleOccursCheck :: EqRel -> TcTyVar -> TcType -> Bool-isInsolubleOccursCheck eq_rel tv ty-  = go ty-  where-    go ty | Just ty' <- tcView ty = go ty'-    go (TyVarTy tv') = tv == tv' || go (tyVarKind tv')-    go (LitTy {})    = False-    go (AppTy t1 t2) = case eq_rel of  -- See Note [AppTy and ReprEq]-                         NomEq  -> go t1 || go t2-                         ReprEq -> go t1-    go (FunTy _ t1 t2) = go t1 || go t2-    go (ForAllTy (Bndr tv' _) inner_ty)-      | tv' == tv = False-      | otherwise = go (varType tv') || go inner_ty-    go (CastTy ty _)  = go ty   -- ToDo: what about the coercion-    go (CoercionTy _) = False   -- ToDo: what about the coercion-    go (TyConApp tc tys)-      | isGenerativeTyCon tc role = any go tys-      | otherwise                 = any go (drop (tyConArity tc) tys)-         -- (a ~ F b a), where F has arity 1,-         -- has an insoluble occurs check--    role = eqRelRole eq_rel--{- Note [Expanding superclasses]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When we expand superclasses, we use the following algorithm:--transSuperClasses( C tys ) returns the transitive superclasses-                           of (C tys), not including C itself--For example-  class C a b => D a b-  class D b a => C a b--Then-  transSuperClasses( Ord ty )  = [Eq ty]-  transSuperClasses( C ta tb ) = [D tb ta, C tb ta]--Notice that in the recursive-superclass case we include C again at-the end of the chain.  One could exclude C in this case, but-the code is more awkward and there seems no good reason to do so.-(However C.f. TcCanonical.mk_strict_superclasses, which /does/-appear to do so.)--The algorithm is expand( so_far, pred ):-- 1. If pred is not a class constraint, return empty set-       Otherwise pred = C ts- 2. If C is in so_far, return empty set (breaks loops)- 3. Find the immediate superclasses constraints of (C ts)- 4. For each such sc_pred, return (sc_pred : expand( so_far+C, D ss )--Notice that-- * With normal Haskell-98 classes, the loop-detector will never bite,-   so we'll get all the superclasses.-- * We need the loop-breaker in case we have UndecidableSuperClasses on-- * Since there is only a finite number of distinct classes, expansion-   must terminate.-- * The loop breaking is a bit conservative. Notably, a tuple class-   could contain many times without threatening termination:-      (Eq a, (Ord a, Ix a))-   And this is try of any class that we can statically guarantee-   as non-recursive (in some sense).  For now, we just make a special-   case for tuples.  Something better would be cool.--See also TcTyDecls.checkClassCycles.--Note [Lift equality constraints when quantifying]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We can't quantify over a constraint (t1 ~# t2) because that isn't a-predicate type; see Note [Types for coercions, predicates, and evidence]-in GHC.Core.TyCo.Rep.--So we have to 'lift' it to (t1 ~ t2).  Similarly (~R#) must be lifted-to Coercible.--This tiresome lifting is the reason that pick_me (in-pickQuantifiablePreds) returns a Maybe rather than a Bool.--Note [Quantifying over equality constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Should we quantify over an equality constraint (s ~ t)?  In general, we don't.-Doing so may simply postpone a type error from the function definition site to-its call site.  (At worst, imagine (Int ~ Bool)).--However, consider this-         forall a. (F [a] ~ Int) => blah-Should we quantify over the (F [a] ~ Int)?  Perhaps yes, because at the call-site we will know 'a', and perhaps we have instance  F [Bool] = Int.-So we *do* quantify over a type-family equality where the arguments mention-the quantified variables.--Note [Inheriting implicit parameters]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider this:--        f x = (x::Int) + ?y--where f is *not* a top-level binding.-From the RHS of f we'll get the constraint (?y::Int).-There are two types we might infer for f:--        f :: Int -> Int--(so we get ?y from the context of f's definition), or--        f :: (?y::Int) => Int -> Int--At first you might think the first was better, because then-?y behaves like a free variable of the definition, rather than-having to be passed at each call site.  But of course, the WHOLE-IDEA is that ?y should be passed at each call site (that's what-dynamic binding means) so we'd better infer the second.--BOTTOM LINE: when *inferring types* you must quantify over implicit-parameters, *even if* they don't mention the bound type variables.-Reason: because implicit parameters, uniquely, have local instance-declarations. See pickQuantifiablePreds.--Note [Quantifying over equality constraints]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Should we quantify over an equality constraint (s ~ t)?  In general, we don't.-Doing so may simply postpone a type error from the function definition site to-its call site.  (At worst, imagine (Int ~ Bool)).--However, consider this-         forall a. (F [a] ~ Int) => blah-Should we quantify over the (F [a] ~ Int).  Perhaps yes, because at the call-site we will know 'a', and perhaps we have instance  F [Bool] = Int.-So we *do* quantify over a type-family equality where the arguments mention-the quantified variables.--************************************************************************-*                                                                      *-      Classifying types-*                                                                      *-************************************************************************--}--isSigmaTy :: TcType -> Bool--- isSigmaTy returns true of any qualified type.  It doesn't--- *necessarily* have any foralls.  E.g---        f :: (?x::Int) => Int -> Int-isSigmaTy ty | Just ty' <- tcView ty = isSigmaTy ty'-isSigmaTy (ForAllTy {})                = True-isSigmaTy (FunTy { ft_af = InvisArg }) = True-isSigmaTy _                            = False--isRhoTy :: TcType -> Bool   -- True of TcRhoTypes; see Note [TcRhoType]-isRhoTy ty | Just ty' <- tcView ty = isRhoTy ty'-isRhoTy (ForAllTy {})                          = False-isRhoTy (FunTy { ft_af = VisArg, ft_res = r }) = isRhoTy r-isRhoTy _                                      = True---- | Like 'isRhoTy', but also says 'True' for 'Infer' types-isRhoExpTy :: ExpType -> Bool-isRhoExpTy (Check ty) = isRhoTy ty-isRhoExpTy (Infer {}) = True--isOverloadedTy :: Type -> Bool--- Yes for a type of a function that might require evidence-passing--- Used only by bindLocalMethods-isOverloadedTy ty | Just ty' <- tcView ty = isOverloadedTy ty'-isOverloadedTy (ForAllTy _  ty)             = isOverloadedTy ty-isOverloadedTy (FunTy { ft_af = InvisArg }) = True-isOverloadedTy _                            = False--isFloatTy, isDoubleTy, isIntegerTy, isIntTy, isWordTy, isBoolTy,-    isUnitTy, isCharTy, isAnyTy :: Type -> Bool-isFloatTy      = is_tc floatTyConKey-isDoubleTy     = is_tc doubleTyConKey-isIntegerTy    = is_tc integerTyConKey-isIntTy        = is_tc intTyConKey-isWordTy       = is_tc wordTyConKey-isBoolTy       = is_tc boolTyConKey-isUnitTy       = is_tc unitTyConKey-isCharTy       = is_tc charTyConKey-isAnyTy        = is_tc anyTyConKey---- | Does a type represent a floating-point number?-isFloatingTy :: Type -> Bool-isFloatingTy ty = isFloatTy ty || isDoubleTy ty---- | Is a type 'String'?-isStringTy :: Type -> Bool-isStringTy ty-  = case tcSplitTyConApp_maybe ty of-      Just (tc, [arg_ty]) -> tc == listTyCon && isCharTy arg_ty-      _                   -> False---- | Is a type a 'CallStack'?-isCallStackTy :: Type -> Bool-isCallStackTy ty-  | Just tc <- tyConAppTyCon_maybe ty-  = tc `hasKey` callStackTyConKey-  | otherwise-  = False---- | Is a 'PredType' a 'CallStack' implicit parameter?------ If so, return the name of the parameter.-isCallStackPred :: Class -> [Type] -> Maybe FastString-isCallStackPred cls tys-  | [ty1, ty2] <- tys-  , isIPClass cls-  , isCallStackTy ty2-  = isStrLitTy ty1-  | otherwise-  = Nothing--is_tc :: Unique -> Type -> Bool--- Newtypes are opaque to this-is_tc uniq ty = case tcSplitTyConApp_maybe ty of-                        Just (tc, _) -> uniq == getUnique tc-                        Nothing      -> False---- | Does the given tyvar appear at the head of a chain of applications---     (a t1 ... tn)-isTyVarHead :: TcTyVar -> TcType -> Bool-isTyVarHead tv (TyVarTy tv')   = tv == tv'-isTyVarHead tv (AppTy fun _)   = isTyVarHead tv fun-isTyVarHead tv (CastTy ty _)   = isTyVarHead tv ty-isTyVarHead _ (TyConApp {})    = False-isTyVarHead _  (LitTy {})      = False-isTyVarHead _  (ForAllTy {})   = False-isTyVarHead _  (FunTy {})      = False-isTyVarHead _  (CoercionTy {}) = False---{- Note [AppTy and ReprEq]-~~~~~~~~~~~~~~~~~~~~~~~~~~-Consider   a ~R# b a-           a ~R# a b--The former is /not/ a definite error; we might instantiate 'b' with Id-   newtype Id a = MkId a-but the latter /is/ a definite error.--On the other hand, with nominal equality, both are definite errors--}--isRigidTy :: TcType -> Bool-isRigidTy ty-  | Just (tc,_) <- tcSplitTyConApp_maybe ty = isGenerativeTyCon tc Nominal-  | Just {} <- tcSplitAppTy_maybe ty        = True-  | isForAllTy ty                           = True-  | otherwise                               = False----- | Is this type *almost function-free*? See Note [Almost function-free]--- in TcRnTypes-isAlmostFunctionFree :: TcType -> Bool-isAlmostFunctionFree ty | Just ty' <- tcView ty = isAlmostFunctionFree ty'-isAlmostFunctionFree (TyVarTy {})    = True-isAlmostFunctionFree (AppTy ty1 ty2) = isAlmostFunctionFree ty1 &&-                                       isAlmostFunctionFree ty2-isAlmostFunctionFree (TyConApp tc args)-  | isTypeFamilyTyCon tc = False-  | otherwise            = all isAlmostFunctionFree args-isAlmostFunctionFree (ForAllTy bndr _) = isAlmostFunctionFree (binderType bndr)-isAlmostFunctionFree (FunTy _ ty1 ty2) = isAlmostFunctionFree ty1 &&-                                         isAlmostFunctionFree ty2-isAlmostFunctionFree (LitTy {})        = True-isAlmostFunctionFree (CastTy ty _)     = isAlmostFunctionFree ty-isAlmostFunctionFree (CoercionTy {})   = True--{--************************************************************************-*                                                                      *-\subsection{Misc}-*                                                                      *-************************************************************************--Note [Visible type application]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-GHC implements a generalisation of the algorithm described in the-"Visible Type Application" paper (available from-http://www.cis.upenn.edu/~sweirich/publications.html). A key part-of that algorithm is to distinguish user-specified variables from inferred-variables. For example, the following should typecheck:--  f :: forall a b. a -> b -> b-  f = const id--  g = const id--  x = f @Int @Bool 5 False-  y = g 5 @Bool False--The idea is that we wish to allow visible type application when we are-instantiating a specified, fixed variable. In practice, specified, fixed-variables are either written in a type signature (or-annotation), OR are imported from another module. (We could do better here,-for example by doing SCC analysis on parts of a module and considering any-type from outside one's SCC to be fully specified, but this is very confusing to-users. The simple rule above is much more straightforward and predictable.)--So, both of f's quantified variables are specified and may be instantiated.-But g has no type signature, so only id's variable is specified (because id-is imported). We write the type of g as forall {a}. a -> forall b. b -> b.-Note that the a is in braces, meaning it cannot be instantiated with-visible type application.--Tracking specified vs. inferred variables is done conveniently by a field-in TyBinder.---}--deNoteType :: Type -> Type--- Remove all *outermost* type synonyms and other notes-deNoteType ty | Just ty' <- coreView ty = deNoteType ty'-deNoteType ty = ty--{--Find the free tycons and classes of a type.  This is used in the front-end of the compiler.--}--{--************************************************************************-*                                                                      *-\subsection[TysWiredIn-ext-type]{External types}-*                                                                      *-************************************************************************--The compiler's foreign function interface supports the passing of a-restricted set of types as arguments and results (the restricting factor-being the )--}--tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type)--- (tcSplitIOType_maybe t) returns Just (IO,t',co)---              if co : t ~ IO t'---              returns Nothing otherwise-tcSplitIOType_maybe ty-  = case tcSplitTyConApp_maybe ty of-        Just (io_tycon, [io_res_ty])-         | io_tycon `hasKey` ioTyConKey ->-            Just (io_tycon, io_res_ty)-        _ ->-            Nothing--isFFITy :: Type -> Bool--- True for any TyCon that can possibly be an arg or result of an FFI call-isFFITy ty = isValid (checkRepTyCon legalFFITyCon ty)--isFFIArgumentTy :: DynFlags -> Safety -> Type -> Validity--- Checks for valid argument type for a 'foreign import'-isFFIArgumentTy dflags safety ty-   = checkRepTyCon (legalOutgoingTyCon dflags safety) ty--isFFIExternalTy :: Type -> Validity--- Types that are allowed as arguments of a 'foreign export'-isFFIExternalTy ty = checkRepTyCon legalFEArgTyCon ty--isFFIImportResultTy :: DynFlags -> Type -> Validity-isFFIImportResultTy dflags ty-  = checkRepTyCon (legalFIResultTyCon dflags) ty--isFFIExportResultTy :: Type -> Validity-isFFIExportResultTy ty = checkRepTyCon legalFEResultTyCon ty--isFFIDynTy :: Type -> Type -> Validity--- The type in a foreign import dynamic must be Ptr, FunPtr, or a newtype of--- either, and the wrapped function type must be equal to the given type.--- We assume that all types have been run through normaliseFfiType, so we don't--- need to worry about expanding newtypes here.-isFFIDynTy expected ty-    -- Note [Foreign import dynamic]-    -- In the example below, expected would be 'CInt -> IO ()', while ty would-    -- be 'FunPtr (CDouble -> IO ())'.-    | Just (tc, [ty']) <- splitTyConApp_maybe ty-    , tyConUnique tc `elem` [ptrTyConKey, funPtrTyConKey]-    , eqType ty' expected-    = IsValid-    | otherwise-    = NotValid (vcat [ text "Expected: Ptr/FunPtr" <+> pprParendType expected <> comma-                     , text "  Actual:" <+> ppr ty ])--isFFILabelTy :: Type -> Validity--- The type of a foreign label must be Ptr, FunPtr, or a newtype of either.-isFFILabelTy ty = checkRepTyCon ok ty-  where-    ok tc | tc `hasKey` funPtrTyConKey || tc `hasKey` ptrTyConKey-          = IsValid-          | otherwise-          = NotValid (text "A foreign-imported address (via &foo) must have type (Ptr a) or (FunPtr a)")--isFFIPrimArgumentTy :: DynFlags -> Type -> Validity--- Checks for valid argument type for a 'foreign import prim'--- Currently they must all be simple unlifted types, or the well-known type--- Any, which can be used to pass the address to a Haskell object on the heap to--- the foreign function.-isFFIPrimArgumentTy dflags ty-  | isAnyTy ty = IsValid-  | otherwise  = checkRepTyCon (legalFIPrimArgTyCon dflags) ty--isFFIPrimResultTy :: DynFlags -> Type -> Validity--- Checks for valid result type for a 'foreign import prim' Currently--- it must be an unlifted type, including unboxed tuples, unboxed--- sums, or the well-known type Any.-isFFIPrimResultTy dflags ty-  | isAnyTy ty = IsValid-  | otherwise = checkRepTyCon (legalFIPrimResultTyCon dflags) ty--isFunPtrTy :: Type -> Bool-isFunPtrTy ty-  | Just (tc, [_]) <- splitTyConApp_maybe ty-  = tc `hasKey` funPtrTyConKey-  | otherwise-  = False---- normaliseFfiType gets run before checkRepTyCon, so we don't--- need to worry about looking through newtypes or type functions--- here; that's already been taken care of.-checkRepTyCon :: (TyCon -> Validity) -> Type -> Validity-checkRepTyCon check_tc ty-  = case splitTyConApp_maybe ty of-      Just (tc, tys)-        | isNewTyCon tc -> NotValid (hang msg 2 (mk_nt_reason tc tys $$ nt_fix))-        | otherwise     -> case check_tc tc of-                             IsValid        -> IsValid-                             NotValid extra -> NotValid (msg $$ extra)-      Nothing -> NotValid (quotes (ppr ty) <+> text "is not a data type")-  where-    msg = quotes (ppr ty) <+> text "cannot be marshalled in a foreign call"-    mk_nt_reason tc tys-      | null tys  = text "because its data constructor is not in scope"-      | otherwise = text "because the data constructor for"-                    <+> quotes (ppr tc) <+> text "is not in scope"-    nt_fix = text "Possible fix: import the data constructor to bring it into scope"--{--Note [Foreign import dynamic]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-A dynamic stub must be of the form 'FunPtr ft -> ft' where ft is any foreign-type.  Similarly, a wrapper stub must be of the form 'ft -> IO (FunPtr ft)'.--We use isFFIDynTy to check whether a signature is well-formed. For example,-given a (illegal) declaration like:--foreign import ccall "dynamic"-  foo :: FunPtr (CDouble -> IO ()) -> CInt -> IO ()--isFFIDynTy will compare the 'FunPtr' type 'CDouble -> IO ()' with the curried-result type 'CInt -> IO ()', and return False, as they are not equal.--------------------------------------------------These chaps do the work; they are not exported-------------------------------------------------}--legalFEArgTyCon :: TyCon -> Validity-legalFEArgTyCon tc-  -- It's illegal to make foreign exports that take unboxed-  -- arguments.  The RTS API currently can't invoke such things.  --SDM 7/2000-  = boxedMarshalableTyCon tc--legalFIResultTyCon :: DynFlags -> TyCon -> Validity-legalFIResultTyCon dflags tc-  | tc == unitTyCon         = IsValid-  | otherwise               = marshalableTyCon dflags tc--legalFEResultTyCon :: TyCon -> Validity-legalFEResultTyCon tc-  | tc == unitTyCon         = IsValid-  | otherwise               = boxedMarshalableTyCon tc--legalOutgoingTyCon :: DynFlags -> Safety -> TyCon -> Validity--- Checks validity of types going from Haskell -> external world-legalOutgoingTyCon dflags _ tc-  = marshalableTyCon dflags tc--legalFFITyCon :: TyCon -> Validity--- True for any TyCon that can possibly be an arg or result of an FFI call-legalFFITyCon tc-  | isUnliftedTyCon tc = IsValid-  | tc == unitTyCon    = IsValid-  | otherwise          = boxedMarshalableTyCon tc--marshalableTyCon :: DynFlags -> TyCon -> Validity-marshalableTyCon dflags tc-  | isUnliftedTyCon tc-  , not (isUnboxedTupleTyCon tc || isUnboxedSumTyCon tc)-  , not (null (tyConPrimRep tc)) -- Note [Marshalling void]-  = validIfUnliftedFFITypes dflags-  | otherwise-  = boxedMarshalableTyCon tc--boxedMarshalableTyCon :: TyCon -> Validity-boxedMarshalableTyCon tc-   | getUnique tc `elem` [ intTyConKey, int8TyConKey, int16TyConKey-                         , int32TyConKey, int64TyConKey-                         , wordTyConKey, word8TyConKey, word16TyConKey-                         , word32TyConKey, word64TyConKey-                         , floatTyConKey, doubleTyConKey-                         , ptrTyConKey, funPtrTyConKey-                         , charTyConKey-                         , stablePtrTyConKey-                         , boolTyConKey-                         ]-  = IsValid--  | otherwise = NotValid empty--legalFIPrimArgTyCon :: DynFlags -> TyCon -> Validity--- Check args of 'foreign import prim', only allow simple unlifted types.--- Strictly speaking it is unnecessary to ban unboxed tuples and sums here since--- currently they're of the wrong kind to use in function args anyway.-legalFIPrimArgTyCon dflags tc-  | isUnliftedTyCon tc-  , not (isUnboxedTupleTyCon tc || isUnboxedSumTyCon tc)-  = validIfUnliftedFFITypes dflags-  | otherwise-  = NotValid unlifted_only--legalFIPrimResultTyCon :: DynFlags -> TyCon -> Validity--- Check result type of 'foreign import prim'. Allow simple unlifted--- types and also unboxed tuple and sum result types.-legalFIPrimResultTyCon dflags tc-  | isUnliftedTyCon tc-  , isUnboxedTupleTyCon tc || isUnboxedSumTyCon tc-     || not (null (tyConPrimRep tc))   -- Note [Marshalling void]-  = validIfUnliftedFFITypes dflags--  | otherwise-  = NotValid unlifted_only--unlifted_only :: MsgDoc-unlifted_only = text "foreign import prim only accepts simple unlifted types"--validIfUnliftedFFITypes :: DynFlags -> Validity-validIfUnliftedFFITypes dflags-  | xopt LangExt.UnliftedFFITypes dflags =  IsValid-  | otherwise = NotValid (text "To marshal unlifted types, use UnliftedFFITypes")--{--Note [Marshalling void]-~~~~~~~~~~~~~~~~~~~~~~~-We don't treat State# (whose PrimRep is VoidRep) as marshalable.-In turn that means you can't write-        foreign import foo :: Int -> State# RealWorld--Reason: the back end falls over with panic "primRepHint:VoidRep";-        and there is no compelling reason to permit it--}--{--************************************************************************-*                                                                      *-        The "Paterson size" of a type-*                                                                      *-************************************************************************--}--{--Note [Paterson conditions on PredTypes]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We are considering whether *class* constraints terminate-(see Note [Paterson conditions]). Precisely, the Paterson conditions-would have us check that "the constraint has fewer constructors and variables-(taken together and counting repetitions) than the head.".--However, we can be a bit more refined by looking at which kind of constraint-this actually is. There are two main tricks:-- 1. It seems like it should be OK not to count the tuple type constructor-    for a PredType like (Show a, Eq a) :: Constraint, since we don't-    count the "implicit" tuple in the ThetaType itself.--    In fact, the Paterson test just checks *each component* of the top level-    ThetaType against the size bound, one at a time. By analogy, it should be-    OK to return the size of the *largest* tuple component as the size of the-    whole tuple.-- 2. Once we get into an implicit parameter or equality we-    can't get back to a class constraint, so it's safe-    to say "size 0".  See #4200.--NB: we don't want to detect PredTypes in sizeType (and then call-sizePred on them), or we might get an infinite loop if that PredType-is irreducible. See #5581.--}--type TypeSize = IntWithInf--sizeType :: Type -> TypeSize--- Size of a type: the number of variables and constructors--- Ignore kinds altogether-sizeType = go-  where-    go ty | Just exp_ty <- tcView ty = go exp_ty-    go (TyVarTy {})              = 1-    go (TyConApp tc tys)-      | isTypeFamilyTyCon tc     = infinity  -- Type-family applications can-                                             -- expand to any arbitrary size-      | otherwise                = sizeTypes (filterOutInvisibleTypes tc tys) + 1-                                   -- Why filter out invisible args?  I suppose any-                                   -- size ordering is sound, but why is this better?-                                   -- I came across this when investigating #14010.-    go (LitTy {})                = 1-    go (FunTy _ arg res)         = go arg + go res + 1-    go (AppTy fun arg)           = go fun + go arg-    go (ForAllTy (Bndr tv vis) ty)-        | isVisibleArgFlag vis   = go (tyVarKind tv) + go ty + 1-        | otherwise              = go ty + 1-    go (CastTy ty _)             = go ty-    go (CoercionTy {})           = 0--sizeTypes :: [Type] -> TypeSize-sizeTypes tys = sum (map sizeType tys)---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | For every arg a tycon can take, the returned list says True if the argument--- is taken visibly, and False otherwise. Ends with an infinite tail of Trues to--- allow for oversaturation.-tcTyConVisibilities :: TyCon -> [Bool]-tcTyConVisibilities tc = tc_binder_viss ++ tc_return_kind_viss ++ repeat True-  where-    tc_binder_viss      = map isVisibleTyConBinder (tyConBinders tc)-    tc_return_kind_viss = map isVisibleBinder (fst $ tcSplitPiTys (tyConResKind tc))---- | If the tycon is applied to the types, is the next argument visible?-isNextTyConArgVisible :: TyCon -> [Type] -> Bool-isNextTyConArgVisible tc tys-  = tcTyConVisibilities tc `getNth` length tys---- | Should this type be applied to a visible argument?-isNextArgVisible :: TcType -> Bool-isNextArgVisible ty-  | Just (bndr, _) <- tcSplitPiTy_maybe ty = isVisibleBinder bndr-  | otherwise                              = True-    -- this second case might happen if, say, we have an unzonked TauTv.-    -- But TauTvs can't range over types that take invisible arguments
− compiler/typecheck/TcType.hs-boot 
@@ -1,8 +0,0 @@-module TcType where-import Outputable( SDoc )--data MetaDetails--data TcTyVarDetails-pprTcTyVarDetails :: TcTyVarDetails -> SDoc-vanillaSkolemTv :: TcTyVarDetails
− compiler/utils/Bag.hs 
@@ -1,335 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998---Bag: an unordered collection with duplicates--}--{-# LANGUAGE ScopedTypeVariables, CPP, DeriveFunctor #-}--module Bag (-        Bag, -- abstract type--        emptyBag, unitBag, unionBags, unionManyBags,-        mapBag,-        elemBag, lengthBag,-        filterBag, partitionBag, partitionBagWith,-        concatBag, catBagMaybes, foldBag,-        isEmptyBag, isSingletonBag, consBag, snocBag, anyBag, allBag,-        listToBag, bagToList, mapAccumBagL,-        concatMapBag, concatMapBagPair, mapMaybeBag,-        mapBagM, mapBagM_,-        flatMapBagM, flatMapBagPairM,-        mapAndUnzipBagM, mapAccumBagLM,-        anyBagM, filterBagM-    ) where--import GhcPrelude--import Outputable-import Util--import MonadUtils-import Control.Monad-import Data.Data-import Data.Maybe( mapMaybe )-import Data.List ( partition, mapAccumL )-import qualified Data.Foldable as Foldable--infixr 3 `consBag`-infixl 3 `snocBag`--data Bag a-  = EmptyBag-  | UnitBag a-  | TwoBags (Bag a) (Bag a) -- INVARIANT: neither branch is empty-  | ListBag [a]             -- INVARIANT: the list is non-empty-  deriving (Functor)--emptyBag :: Bag a-emptyBag = EmptyBag--unitBag :: a -> Bag a-unitBag  = UnitBag--lengthBag :: Bag a -> Int-lengthBag EmptyBag        = 0-lengthBag (UnitBag {})    = 1-lengthBag (TwoBags b1 b2) = lengthBag b1 + lengthBag b2-lengthBag (ListBag xs)    = length xs--elemBag :: Eq a => a -> Bag a -> Bool-elemBag _ EmptyBag        = False-elemBag x (UnitBag y)     = x == y-elemBag x (TwoBags b1 b2) = x `elemBag` b1 || x `elemBag` b2-elemBag x (ListBag ys)    = any (x ==) ys--unionManyBags :: [Bag a] -> Bag a-unionManyBags xs = foldr unionBags EmptyBag xs---- This one is a bit stricter! The bag will get completely evaluated.--unionBags :: Bag a -> Bag a -> Bag a-unionBags EmptyBag b = b-unionBags b EmptyBag = b-unionBags b1 b2      = TwoBags b1 b2--consBag :: a -> Bag a -> Bag a-snocBag :: Bag a -> a -> Bag a--consBag elt bag = (unitBag elt) `unionBags` bag-snocBag bag elt = bag `unionBags` (unitBag elt)--isEmptyBag :: Bag a -> Bool-isEmptyBag EmptyBag = True-isEmptyBag _        = False -- NB invariants--isSingletonBag :: Bag a -> Bool-isSingletonBag EmptyBag      = False-isSingletonBag (UnitBag _)   = True-isSingletonBag (TwoBags _ _) = False          -- Neither is empty-isSingletonBag (ListBag xs)  = isSingleton xs--filterBag :: (a -> Bool) -> Bag a -> Bag a-filterBag _    EmptyBag = EmptyBag-filterBag pred b@(UnitBag val) = if pred val then b else EmptyBag-filterBag pred (TwoBags b1 b2) = sat1 `unionBags` sat2-    where sat1 = filterBag pred b1-          sat2 = filterBag pred b2-filterBag pred (ListBag vs)    = listToBag (filter pred vs)--filterBagM :: Monad m => (a -> m Bool) -> Bag a -> m (Bag a)-filterBagM _    EmptyBag = return EmptyBag-filterBagM pred b@(UnitBag val) = do-  flag <- pred val-  if flag then return b-          else return EmptyBag-filterBagM pred (TwoBags b1 b2) = do-  sat1 <- filterBagM pred b1-  sat2 <- filterBagM pred b2-  return (sat1 `unionBags` sat2)-filterBagM pred (ListBag vs) = do-  sat <- filterM pred vs-  return (listToBag sat)--allBag :: (a -> Bool) -> Bag a -> Bool-allBag _ EmptyBag        = True-allBag p (UnitBag v)     = p v-allBag p (TwoBags b1 b2) = allBag p b1 && allBag p b2-allBag p (ListBag xs)    = all p xs--anyBag :: (a -> Bool) -> Bag a -> Bool-anyBag _ EmptyBag        = False-anyBag p (UnitBag v)     = p v-anyBag p (TwoBags b1 b2) = anyBag p b1 || anyBag p b2-anyBag p (ListBag xs)    = any p xs--anyBagM :: Monad m => (a -> m Bool) -> Bag a -> m Bool-anyBagM _ EmptyBag        = return False-anyBagM p (UnitBag v)     = p v-anyBagM p (TwoBags b1 b2) = do flag <- anyBagM p b1-                               if flag then return True-                                       else anyBagM p b2-anyBagM p (ListBag xs)    = anyM p xs--concatBag :: Bag (Bag a) -> Bag a-concatBag bss = foldr add emptyBag bss-  where-    add bs rs = bs `unionBags` rs--catBagMaybes :: Bag (Maybe a) -> Bag a-catBagMaybes bs = foldr add emptyBag bs-  where-    add Nothing rs = rs-    add (Just x) rs = x `consBag` rs--partitionBag :: (a -> Bool) -> Bag a -> (Bag a {- Satisfy predictate -},-                                         Bag a {- Don't -})-partitionBag _    EmptyBag = (EmptyBag, EmptyBag)-partitionBag pred b@(UnitBag val)-    = if pred val then (b, EmptyBag) else (EmptyBag, b)-partitionBag pred (TwoBags b1 b2)-    = (sat1 `unionBags` sat2, fail1 `unionBags` fail2)-  where (sat1, fail1) = partitionBag pred b1-        (sat2, fail2) = partitionBag pred b2-partitionBag pred (ListBag vs) = (listToBag sats, listToBag fails)-  where (sats, fails) = partition pred vs---partitionBagWith :: (a -> Either b c) -> Bag a-                    -> (Bag b {- Left  -},-                        Bag c {- Right -})-partitionBagWith _    EmptyBag = (EmptyBag, EmptyBag)-partitionBagWith pred (UnitBag val)-    = case pred val of-         Left a  -> (UnitBag a, EmptyBag)-         Right b -> (EmptyBag, UnitBag b)-partitionBagWith pred (TwoBags b1 b2)-    = (sat1 `unionBags` sat2, fail1 `unionBags` fail2)-  where (sat1, fail1) = partitionBagWith pred b1-        (sat2, fail2) = partitionBagWith pred b2-partitionBagWith pred (ListBag vs) = (listToBag sats, listToBag fails)-  where (sats, fails) = partitionWith pred vs--foldBag :: (r -> r -> r) -- Replace TwoBags with this; should be associative-        -> (a -> r)      -- Replace UnitBag with this-        -> r             -- Replace EmptyBag with this-        -> Bag a-        -> r--{- Standard definition-foldBag t u e EmptyBag        = e-foldBag t u e (UnitBag x)     = u x-foldBag t u e (TwoBags b1 b2) = (foldBag t u e b1) `t` (foldBag t u e b2)-foldBag t u e (ListBag xs)    = foldr (t.u) e xs--}---- More tail-recursive definition, exploiting associativity of "t"-foldBag _ _ e EmptyBag        = e-foldBag t u e (UnitBag x)     = u x `t` e-foldBag t u e (TwoBags b1 b2) = foldBag t u (foldBag t u e b2) b1-foldBag t u e (ListBag xs)    = foldr (t.u) e xs--mapBag :: (a -> b) -> Bag a -> Bag b-mapBag = fmap--concatMapBag :: (a -> Bag b) -> Bag a -> Bag b-concatMapBag _ EmptyBag        = EmptyBag-concatMapBag f (UnitBag x)     = f x-concatMapBag f (TwoBags b1 b2) = unionBags (concatMapBag f b1) (concatMapBag f b2)-concatMapBag f (ListBag xs)    = foldr (unionBags . f) emptyBag xs--concatMapBagPair :: (a -> (Bag b, Bag c)) -> Bag a -> (Bag b, Bag c)-concatMapBagPair _ EmptyBag        = (EmptyBag, EmptyBag)-concatMapBagPair f (UnitBag x)     = f x-concatMapBagPair f (TwoBags b1 b2) = (unionBags r1 r2, unionBags s1 s2)-  where-    (r1, s1) = concatMapBagPair f b1-    (r2, s2) = concatMapBagPair f b2-concatMapBagPair f (ListBag xs)    = foldr go (emptyBag, emptyBag) xs-  where-    go a (s1, s2) = (unionBags r1 s1, unionBags r2 s2)-      where-        (r1, r2) = f a--mapMaybeBag :: (a -> Maybe b) -> Bag a -> Bag b-mapMaybeBag _ EmptyBag        = EmptyBag-mapMaybeBag f (UnitBag x)     = case f x of-                                  Nothing -> EmptyBag-                                  Just y  -> UnitBag y-mapMaybeBag f (TwoBags b1 b2) = unionBags (mapMaybeBag f b1) (mapMaybeBag f b2)-mapMaybeBag f (ListBag xs)    = ListBag (mapMaybe f xs)--mapBagM :: Monad m => (a -> m b) -> Bag a -> m (Bag b)-mapBagM _ EmptyBag        = return EmptyBag-mapBagM f (UnitBag x)     = do r <- f x-                               return (UnitBag r)-mapBagM f (TwoBags b1 b2) = do r1 <- mapBagM f b1-                               r2 <- mapBagM f b2-                               return (TwoBags r1 r2)-mapBagM f (ListBag    xs) = do rs <- mapM f xs-                               return (ListBag rs)--mapBagM_ :: Monad m => (a -> m b) -> Bag a -> m ()-mapBagM_ _ EmptyBag        = return ()-mapBagM_ f (UnitBag x)     = f x >> return ()-mapBagM_ f (TwoBags b1 b2) = mapBagM_ f b1 >> mapBagM_ f b2-mapBagM_ f (ListBag    xs) = mapM_ f xs--flatMapBagM :: Monad m => (a -> m (Bag b)) -> Bag a -> m (Bag b)-flatMapBagM _ EmptyBag        = return EmptyBag-flatMapBagM f (UnitBag x)     = f x-flatMapBagM f (TwoBags b1 b2) = do r1 <- flatMapBagM f b1-                                   r2 <- flatMapBagM f b2-                                   return (r1 `unionBags` r2)-flatMapBagM f (ListBag    xs) = foldrM k EmptyBag xs-  where-    k x b2 = do { b1 <- f x; return (b1 `unionBags` b2) }--flatMapBagPairM :: Monad m => (a -> m (Bag b, Bag c)) -> Bag a -> m (Bag b, Bag c)-flatMapBagPairM _ EmptyBag        = return (EmptyBag, EmptyBag)-flatMapBagPairM f (UnitBag x)     = f x-flatMapBagPairM f (TwoBags b1 b2) = do (r1,s1) <- flatMapBagPairM f b1-                                       (r2,s2) <- flatMapBagPairM f b2-                                       return (r1 `unionBags` r2, s1 `unionBags` s2)-flatMapBagPairM f (ListBag    xs) = foldrM k (EmptyBag, EmptyBag) xs-  where-    k x (r2,s2) = do { (r1,s1) <- f x-                     ; return (r1 `unionBags` r2, s1 `unionBags` s2) }--mapAndUnzipBagM :: Monad m => (a -> m (b,c)) -> Bag a -> m (Bag b, Bag c)-mapAndUnzipBagM _ EmptyBag        = return (EmptyBag, EmptyBag)-mapAndUnzipBagM f (UnitBag x)     = do (r,s) <- f x-                                       return (UnitBag r, UnitBag s)-mapAndUnzipBagM f (TwoBags b1 b2) = do (r1,s1) <- mapAndUnzipBagM f b1-                                       (r2,s2) <- mapAndUnzipBagM f b2-                                       return (TwoBags r1 r2, TwoBags s1 s2)-mapAndUnzipBagM f (ListBag xs)    = do ts <- mapM f xs-                                       let (rs,ss) = unzip ts-                                       return (ListBag rs, ListBag ss)--mapAccumBagL ::(acc -> x -> (acc, y)) -- ^ combining function-            -> acc                    -- ^ initial state-            -> Bag x                  -- ^ inputs-            -> (acc, Bag y)           -- ^ final state, outputs-mapAccumBagL _ s EmptyBag        = (s, EmptyBag)-mapAccumBagL f s (UnitBag x)     = let (s1, x1) = f s x in (s1, UnitBag x1)-mapAccumBagL f s (TwoBags b1 b2) = let (s1, b1') = mapAccumBagL f s  b1-                                       (s2, b2') = mapAccumBagL f s1 b2-                                   in (s2, TwoBags b1' b2')-mapAccumBagL f s (ListBag xs)    = let (s', xs') = mapAccumL f s xs-                                   in (s', ListBag xs')--mapAccumBagLM :: Monad m-            => (acc -> x -> m (acc, y)) -- ^ combining function-            -> acc                      -- ^ initial state-            -> Bag x                    -- ^ inputs-            -> m (acc, Bag y)           -- ^ final state, outputs-mapAccumBagLM _ s EmptyBag        = return (s, EmptyBag)-mapAccumBagLM f s (UnitBag x)     = do { (s1, x1) <- f s x; return (s1, UnitBag x1) }-mapAccumBagLM f s (TwoBags b1 b2) = do { (s1, b1') <- mapAccumBagLM f s  b1-                                       ; (s2, b2') <- mapAccumBagLM f s1 b2-                                       ; return (s2, TwoBags b1' b2') }-mapAccumBagLM f s (ListBag xs)    = do { (s', xs') <- mapAccumLM f s xs-                                       ; return (s', ListBag xs') }--listToBag :: [a] -> Bag a-listToBag [] = EmptyBag-listToBag [x] = UnitBag x-listToBag vs = ListBag vs--bagToList :: Bag a -> [a]-bagToList b = foldr (:) [] b--instance (Outputable a) => Outputable (Bag a) where-    ppr bag = braces (pprWithCommas ppr (bagToList bag))--instance Data a => Data (Bag a) where-  gfoldl k z b = z listToBag `k` bagToList b -- traverse abstract type abstractly-  toConstr _   = abstractConstr $ "Bag("++show (typeOf (undefined::a))++")"-  gunfold _ _  = error "gunfold"-  dataTypeOf _ = mkNoRepType "Bag"-  dataCast1 x  = gcast1 x--instance Foldable.Foldable Bag where-  foldr _ z EmptyBag        = z-  foldr k z (UnitBag x)     = k x z-  foldr k z (TwoBags b1 b2) = foldr k (foldr k z b2) b1-  foldr k z (ListBag xs)    = foldr k z xs--  foldl _ z EmptyBag        = z-  foldl k z (UnitBag x)     = k z x-  foldl k z (TwoBags b1 b2) = foldl k (foldl k z b1) b2-  foldl k z (ListBag xs)    = foldl k z xs--  foldl' _ z EmptyBag        = z-  foldl' k z (UnitBag x)     = k z x-  foldl' k z (TwoBags b1 b2) = let r1 = foldl' k z b1 in seq r1 $ foldl' k r1 b2-  foldl' k z (ListBag xs)    = foldl' k z xs--instance Traversable Bag where-  traverse _ EmptyBag        = pure EmptyBag-  traverse f (UnitBag x)     = UnitBag <$> f x-  traverse f (TwoBags b1 b2) = TwoBags <$> traverse f b1 <*> traverse f b2-  traverse f (ListBag xs)    = ListBag <$> traverse f xs
− compiler/utils/Binary.hs 
@@ -1,1416 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE PolyKinds #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE GADTs #-}-{-# LANGUAGE MultiWayIf #-}-{-# LANGUAGE BangPatterns #-}--{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}--- We always optimise this, otherwise performance of a non-optimised--- compiler is severely affected------- (c) The University of Glasgow 2002-2006------ Binary I/O library, with special tweaks for GHC------ Based on the nhc98 Binary library, which is copyright--- (c) Malcolm Wallace and Colin Runciman, University of York, 1998.--- Under the terms of the license for that software, we must tell you--- where you can obtain the original version of the Binary library, namely---     http://www.cs.york.ac.uk/fp/nhc98/--module Binary-  ( {-type-}  Bin,-    {-class-} Binary(..),-    {-type-}  BinHandle,-    SymbolTable, Dictionary,--   openBinMem,---   closeBin,--   seekBin,-   tellBin,-   castBin,-   withBinBuffer,--   writeBinMem,-   readBinMem,--   putAt, getAt,--   -- * For writing instances-   putByte,-   getByte,--   -- * Variable length encodings-   putULEB128,-   getULEB128,-   putSLEB128,-   getSLEB128,--   -- * Lazy Binary I/O-   lazyGet,-   lazyPut,--   -- * User data-   UserData(..), getUserData, setUserData,-   newReadState, newWriteState,-   putDictionary, getDictionary, putFS,-  ) where--#include "HsVersions.h"--import GhcPrelude--import {-# SOURCE #-} GHC.Types.Name (Name)-import FastString-import PlainPanic-import GHC.Types.Unique.FM-import FastMutInt-import Fingerprint-import GHC.Types.Basic-import GHC.Types.SrcLoc--import Foreign-import Data.Array-import Data.ByteString (ByteString)-import qualified Data.ByteString.Internal as BS-import qualified Data.ByteString.Unsafe   as BS-import Data.IORef-import Data.Char                ( ord, chr )-import Data.Time-import Data.List (unfoldr)-import Type.Reflection-import Type.Reflection.Unsafe-import Data.Kind (Type)-import GHC.Exts (TYPE, RuntimeRep(..), VecCount(..), VecElem(..))-import Control.Monad            ( when, (<$!>), unless )-import System.IO as IO-import System.IO.Unsafe         ( unsafeInterleaveIO )-import System.IO.Error          ( mkIOError, eofErrorType )-import GHC.Real                 ( Ratio(..) )-import GHC.Serialized--type BinArray = ForeignPtr Word8-------------------------------------------------------------------- BinHandle------------------------------------------------------------------data BinHandle-  = BinMem {                     -- binary data stored in an unboxed array-     bh_usr :: UserData,         -- sigh, need parameterized modules :-)-     _off_r :: !FastMutInt,      -- the current offset-     _sz_r  :: !FastMutInt,      -- size of the array (cached)-     _arr_r :: !(IORef BinArray) -- the array (bounds: (0,size-1))-    }-        -- XXX: should really store a "high water mark" for dumping out-        -- the binary data to a file.--getUserData :: BinHandle -> UserData-getUserData bh = bh_usr bh--setUserData :: BinHandle -> UserData -> BinHandle-setUserData bh us = bh { bh_usr = us }---- | Get access to the underlying buffer.------ It is quite important that no references to the 'ByteString' leak out of the--- continuation lest terrible things happen.-withBinBuffer :: BinHandle -> (ByteString -> IO a) -> IO a-withBinBuffer (BinMem _ ix_r _ arr_r) action = do-  arr <- readIORef arr_r-  ix <- readFastMutInt ix_r-  withForeignPtr arr $ \ptr ->-    BS.unsafePackCStringLen (castPtr ptr, ix) >>= action--------------------------------------------------------------------- Bin------------------------------------------------------------------newtype Bin a = BinPtr Int-  deriving (Eq, Ord, Show, Bounded)--castBin :: Bin a -> Bin b-castBin (BinPtr i) = BinPtr i-------------------------------------------------------------------- class Binary-------------------------------------------------------------------- | Do not rely on instance sizes for general types,--- we use variable length encoding for many of them.-class Binary a where-    put_   :: BinHandle -> a -> IO ()-    put    :: BinHandle -> a -> IO (Bin a)-    get    :: BinHandle -> IO a--    -- define one of put_, put.  Use of put_ is recommended because it-    -- is more likely that tail-calls can kick in, and we rarely need the-    -- position return value.-    put_ bh a = do _ <- put bh a; return ()-    put bh a  = do p <- tellBin bh; put_ bh a; return p--putAt  :: Binary a => BinHandle -> Bin a -> a -> IO ()-putAt bh p x = do seekBin bh p; put_ bh x; return ()--getAt  :: Binary a => BinHandle -> Bin a -> IO a-getAt bh p = do seekBin bh p; get bh--openBinMem :: Int -> IO BinHandle-openBinMem size- | size <= 0 = error "Data.Binary.openBinMem: size must be >= 0"- | otherwise = do-   arr <- mallocForeignPtrBytes size-   arr_r <- newIORef arr-   ix_r <- newFastMutInt-   writeFastMutInt ix_r 0-   sz_r <- newFastMutInt-   writeFastMutInt sz_r size-   return (BinMem noUserData ix_r sz_r arr_r)--tellBin :: BinHandle -> IO (Bin a)-tellBin (BinMem _ r _ _) = do ix <- readFastMutInt r; return (BinPtr ix)--seekBin :: BinHandle -> Bin a -> IO ()-seekBin h@(BinMem _ ix_r sz_r _) (BinPtr !p) = do-  sz <- readFastMutInt sz_r-  if (p >= sz)-        then do expandBin h p; writeFastMutInt ix_r p-        else writeFastMutInt ix_r p--writeBinMem :: BinHandle -> FilePath -> IO ()-writeBinMem (BinMem _ ix_r _ arr_r) fn = do-  h <- openBinaryFile fn WriteMode-  arr <- readIORef arr_r-  ix  <- readFastMutInt ix_r-  withForeignPtr arr $ \p -> hPutBuf h p ix-  hClose h--readBinMem :: FilePath -> IO BinHandle--- Return a BinHandle with a totally undefined State-readBinMem filename = do-  h <- openBinaryFile filename ReadMode-  filesize' <- hFileSize h-  let filesize = fromIntegral filesize'-  arr <- mallocForeignPtrBytes filesize-  count <- withForeignPtr arr $ \p -> hGetBuf h p filesize-  when (count /= filesize) $-       error ("Binary.readBinMem: only read " ++ show count ++ " bytes")-  hClose h-  arr_r <- newIORef arr-  ix_r <- newFastMutInt-  writeFastMutInt ix_r 0-  sz_r <- newFastMutInt-  writeFastMutInt sz_r filesize-  return (BinMem noUserData ix_r sz_r arr_r)---- expand the size of the array to include a specified offset-expandBin :: BinHandle -> Int -> IO ()-expandBin (BinMem _ _ sz_r arr_r) !off = do-   !sz <- readFastMutInt sz_r-   let !sz' = getSize sz-   arr <- readIORef arr_r-   arr' <- mallocForeignPtrBytes sz'-   withForeignPtr arr $ \old ->-     withForeignPtr arr' $ \new ->-       copyBytes new old sz-   writeFastMutInt sz_r sz'-   writeIORef arr_r arr'-   where-    getSize :: Int -> Int-    getSize !sz-      | sz > off-      = sz-      | otherwise-      = getSize (sz * 2)---- -------------------------------------------------------------------------------- Low-level reading/writing of bytes---- | Takes a size and action writing up to @size@ bytes.---   After the action has run advance the index to the buffer---   by size bytes.-putPrim :: BinHandle -> Int -> (Ptr Word8 -> IO ()) -> IO ()-putPrim h@(BinMem _ ix_r sz_r arr_r) size f = do-  ix <- readFastMutInt ix_r-  sz <- readFastMutInt sz_r-  when (ix + size > sz) $-    expandBin h (ix + size)-  arr <- readIORef arr_r-  withForeignPtr arr $ \op -> f (op `plusPtr` ix)-  writeFastMutInt ix_r (ix + size)---- -- | Similar to putPrim but advances the index by the actual number of--- -- bytes written.--- putPrimMax :: BinHandle -> Int -> (Ptr Word8 -> IO Int) -> IO ()--- putPrimMax h@(BinMem _ ix_r sz_r arr_r) size f = do---   ix <- readFastMutInt ix_r---   sz <- readFastMutInt sz_r---   when (ix + size > sz) $---     expandBin h (ix + size)---   arr <- readIORef arr_r---   written <- withForeignPtr arr $ \op -> f (op `plusPtr` ix)---   writeFastMutInt ix_r (ix + written)--getPrim :: BinHandle -> Int -> (Ptr Word8 -> IO a) -> IO a-getPrim (BinMem _ ix_r sz_r arr_r) size f = do-  ix <- readFastMutInt ix_r-  sz <- readFastMutInt sz_r-  when (ix + size > sz) $-      ioError (mkIOError eofErrorType "Data.Binary.getPrim" Nothing Nothing)-  arr <- readIORef arr_r-  w <- withForeignPtr arr $ \op -> f (op `plusPtr` ix)-  writeFastMutInt ix_r (ix + size)-  return w--putWord8 :: BinHandle -> Word8 -> IO ()-putWord8 h !w = putPrim h 1 (\op -> poke op w)--getWord8 :: BinHandle -> IO Word8-getWord8 h = getPrim h 1 peek---- putWord16 :: BinHandle -> Word16 -> IO ()--- putWord16 h w = putPrim h 2 (\op -> do---   pokeElemOff op 0 (fromIntegral (w `shiftR` 8))---   pokeElemOff op 1 (fromIntegral (w .&. 0xFF))---   )---- getWord16 :: BinHandle -> IO Word16--- getWord16 h = getPrim h 2 (\op -> do---   w0 <- fromIntegral <$> peekElemOff op 0---   w1 <- fromIntegral <$> peekElemOff op 1---   return $! w0 `shiftL` 8 .|. w1---   )--putWord32 :: BinHandle -> Word32 -> IO ()-putWord32 h w = putPrim h 4 (\op -> do-  pokeElemOff op 0 (fromIntegral (w `shiftR` 24))-  pokeElemOff op 1 (fromIntegral ((w `shiftR` 16) .&. 0xFF))-  pokeElemOff op 2 (fromIntegral ((w `shiftR` 8) .&. 0xFF))-  pokeElemOff op 3 (fromIntegral (w .&. 0xFF))-  )--getWord32 :: BinHandle -> IO Word32-getWord32 h = getPrim h 4 (\op -> do-  w0 <- fromIntegral <$> peekElemOff op 0-  w1 <- fromIntegral <$> peekElemOff op 1-  w2 <- fromIntegral <$> peekElemOff op 2-  w3 <- fromIntegral <$> peekElemOff op 3--  return $! (w0 `shiftL` 24) .|.-            (w1 `shiftL` 16) .|.-            (w2 `shiftL` 8)  .|.-            w3-  )---- putWord64 :: BinHandle -> Word64 -> IO ()--- putWord64 h w = putPrim h 8 (\op -> do---   pokeElemOff op 0 (fromIntegral (w `shiftR` 56))---   pokeElemOff op 1 (fromIntegral ((w `shiftR` 48) .&. 0xFF))---   pokeElemOff op 2 (fromIntegral ((w `shiftR` 40) .&. 0xFF))---   pokeElemOff op 3 (fromIntegral ((w `shiftR` 32) .&. 0xFF))---   pokeElemOff op 4 (fromIntegral ((w `shiftR` 24) .&. 0xFF))---   pokeElemOff op 5 (fromIntegral ((w `shiftR` 16) .&. 0xFF))---   pokeElemOff op 6 (fromIntegral ((w `shiftR` 8) .&. 0xFF))---   pokeElemOff op 7 (fromIntegral (w .&. 0xFF))---   )---- getWord64 :: BinHandle -> IO Word64--- getWord64 h = getPrim h 8 (\op -> do---   w0 <- fromIntegral <$> peekElemOff op 0---   w1 <- fromIntegral <$> peekElemOff op 1---   w2 <- fromIntegral <$> peekElemOff op 2---   w3 <- fromIntegral <$> peekElemOff op 3---   w4 <- fromIntegral <$> peekElemOff op 4---   w5 <- fromIntegral <$> peekElemOff op 5---   w6 <- fromIntegral <$> peekElemOff op 6---   w7 <- fromIntegral <$> peekElemOff op 7----   return $! (w0 `shiftL` 56) .|.---             (w1 `shiftL` 48) .|.---             (w2 `shiftL` 40) .|.---             (w3 `shiftL` 32) .|.---             (w4 `shiftL` 24) .|.---             (w5 `shiftL` 16) .|.---             (w6 `shiftL` 8)  .|.---             w7---   )--putByte :: BinHandle -> Word8 -> IO ()-putByte bh !w = putWord8 bh w--getByte :: BinHandle -> IO Word8-getByte h = getWord8 h---- -------------------------------------------------------------------------------- Encode numbers in LEB128 encoding.--- Requires one byte of space per 7 bits of data.------ There are signed and unsigned variants.--- Do NOT use the unsigned one for signed values, at worst it will--- result in wrong results, at best it will lead to bad performance--- when coercing negative values to an unsigned type.------ We mark them as SPECIALIZE as it's extremely critical that they get specialized--- to their specific types.------ TODO: Each use of putByte performs a bounds check,---       we should use putPrimMax here. However it's quite hard to return---       the number of bytes written into putPrimMax without allocating an---       Int for it, while the code below does not allocate at all.---       So we eat the cost of the bounds check instead of increasing allocations---       for now.---- Unsigned numbers-{-# SPECIALISE putULEB128 :: BinHandle -> Word -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Word64 -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Word32 -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Word16 -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Int -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Int64 -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Int32 -> IO () #-}-{-# SPECIALISE putULEB128 :: BinHandle -> Int16 -> IO () #-}-putULEB128 :: forall a. (Integral a, FiniteBits a) => BinHandle -> a -> IO ()-putULEB128 bh w =-#if defined(DEBUG)-    (if w < 0 then panic "putULEB128: Signed number" else id) $-#endif-    go w-  where-    go :: a -> IO ()-    go w-      | w <= (127 :: a)-      = putByte bh (fromIntegral w :: Word8)-      | otherwise = do-        -- bit 7 (8th bit) indicates more to come.-        let !byte = setBit (fromIntegral w) 7 :: Word8-        putByte bh byte-        go (w `unsafeShiftR` 7)--{-# SPECIALISE getULEB128 :: BinHandle -> IO Word #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Word64 #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Word32 #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Word16 #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Int #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Int64 #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Int32 #-}-{-# SPECIALISE getULEB128 :: BinHandle -> IO Int16 #-}-getULEB128 :: forall a. (Integral a, FiniteBits a) => BinHandle -> IO a-getULEB128 bh =-    go 0 0-  where-    go :: Int -> a -> IO a-    go shift w = do-        b <- getByte bh-        let !hasMore = testBit b 7-        let !val = w .|. ((clearBit (fromIntegral b) 7) `unsafeShiftL` shift) :: a-        if hasMore-            then do-                go (shift+7) val-            else-                return $! val---- Signed numbers-{-# SPECIALISE putSLEB128 :: BinHandle -> Word -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Word64 -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Word32 -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Word16 -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Int -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Int64 -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Int32 -> IO () #-}-{-# SPECIALISE putSLEB128 :: BinHandle -> Int16 -> IO () #-}-putSLEB128 :: forall a. (Integral a, Bits a) => BinHandle -> a -> IO ()-putSLEB128 bh initial = go initial-  where-    go :: a -> IO ()-    go val = do-        let !byte = fromIntegral (clearBit val 7) :: Word8-        let !val' = val `unsafeShiftR` 7-        let !signBit = testBit byte 6-        let !done =-                -- Unsigned value, val' == 0 and last value can-                -- be discriminated from a negative number.-                ((val' == 0 && not signBit) ||-                -- Signed value,-                 (val' == -1 && signBit))--        let !byte' = if done then byte else setBit byte 7-        putByte bh byte'--        unless done $ go val'--{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word64 #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word32 #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Word16 #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int64 #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int32 #-}-{-# SPECIALISE getSLEB128 :: BinHandle -> IO Int16 #-}-getSLEB128 :: forall a. (Show a, Integral a, FiniteBits a) => BinHandle -> IO a-getSLEB128 bh = do-    (val,shift,signed) <- go 0 0-    if signed && (shift < finiteBitSize val )-        then return $! ((complement 0 `unsafeShiftL` shift) .|. val)-        else return val-    where-        go :: Int -> a -> IO (a,Int,Bool)-        go shift val = do-            byte <- getByte bh-            let !byteVal = fromIntegral (clearBit byte 7) :: a-            let !val' = val .|. (byteVal `unsafeShiftL` shift)-            let !more = testBit byte 7-            let !shift' = shift+7-            if more-                then go (shift') val'-                else do-                    let !signed = testBit byte 6-                    return (val',shift',signed)---- -------------------------------------------------------------------------------- Primitive Word writes--instance Binary Word8 where-  put_ bh !w = putWord8 bh w-  get  = getWord8--instance Binary Word16 where-  put_ = putULEB128-  get  = getULEB128--instance Binary Word32 where-  put_ = putULEB128-  get  = getULEB128--instance Binary Word64 where-  put_ = putULEB128-  get = getULEB128---- -------------------------------------------------------------------------------- Primitive Int writes--instance Binary Int8 where-  put_ h w = put_ h (fromIntegral w :: Word8)-  get h    = do w <- get h; return $! (fromIntegral (w::Word8))--instance Binary Int16 where-  put_ = putSLEB128-  get = getSLEB128--instance Binary Int32 where-  put_ = putSLEB128-  get = getSLEB128--instance Binary Int64 where-  put_ h w = putSLEB128 h w-  get h    = getSLEB128 h---- -------------------------------------------------------------------------------- Instances for standard types--instance Binary () where-    put_ _ () = return ()-    get  _    = return ()--instance Binary Bool where-    put_ bh b = putByte bh (fromIntegral (fromEnum b))-    get  bh   = do x <- getWord8 bh; return $! (toEnum (fromIntegral x))--instance Binary Char where-    put_  bh c = put_ bh (fromIntegral (ord c) :: Word32)-    get  bh   = do x <- get bh; return $! (chr (fromIntegral (x :: Word32)))--instance Binary Int where-    put_ bh i = put_ bh (fromIntegral i :: Int64)-    get  bh = do-        x <- get bh-        return $! (fromIntegral (x :: Int64))--instance Binary a => Binary [a] where-    put_ bh l = do-        let len = length l-        put_ bh len-        mapM_ (put_ bh) l-    get bh = do-        len <- get bh :: IO Int -- Int is variable length encoded so only-                                -- one byte for small lists.-        let loop 0 = return []-            loop n = do a <- get bh; as <- loop (n-1); return (a:as)-        loop len--instance (Ix a, Binary a, Binary b) => Binary (Array a b) where-    put_ bh arr = do-        put_ bh $ bounds arr-        put_ bh $ elems arr-    get bh = do-        bounds <- get bh-        xs <- get bh-        return $ listArray bounds xs--instance (Binary a, Binary b) => Binary (a,b) where-    put_ bh (a,b) = do put_ bh a; put_ bh b-    get bh        = do a <- get bh-                       b <- get bh-                       return (a,b)--instance (Binary a, Binary b, Binary c) => Binary (a,b,c) where-    put_ bh (a,b,c) = do put_ bh a; put_ bh b; put_ bh c-    get bh          = do a <- get bh-                         b <- get bh-                         c <- get bh-                         return (a,b,c)--instance (Binary a, Binary b, Binary c, Binary d) => Binary (a,b,c,d) where-    put_ bh (a,b,c,d) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d-    get bh            = do a <- get bh-                           b <- get bh-                           c <- get bh-                           d <- get bh-                           return (a,b,c,d)--instance (Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a,b,c,d, e) where-    put_ bh (a,b,c,d, e) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e;-    get bh               = do a <- get bh-                              b <- get bh-                              c <- get bh-                              d <- get bh-                              e <- get bh-                              return (a,b,c,d,e)--instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a,b,c,d, e, f) where-    put_ bh (a,b,c,d, e, f) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e; put_ bh f;-    get bh                  = do a <- get bh-                                 b <- get bh-                                 c <- get bh-                                 d <- get bh-                                 e <- get bh-                                 f <- get bh-                                 return (a,b,c,d,e,f)--instance (Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a,b,c,d,e,f,g) where-    put_ bh (a,b,c,d,e,f,g) = do put_ bh a; put_ bh b; put_ bh c; put_ bh d; put_ bh e; put_ bh f; put_ bh g-    get bh                  = do a <- get bh-                                 b <- get bh-                                 c <- get bh-                                 d <- get bh-                                 e <- get bh-                                 f <- get bh-                                 g <- get bh-                                 return (a,b,c,d,e,f,g)--instance Binary a => Binary (Maybe a) where-    put_ bh Nothing  = putByte bh 0-    put_ bh (Just a) = do putByte bh 1; put_ bh a-    get bh           = do h <- getWord8 bh-                          case h of-                            0 -> return Nothing-                            _ -> do x <- get bh; return (Just x)--instance (Binary a, Binary b) => Binary (Either a b) where-    put_ bh (Left  a) = do putByte bh 0; put_ bh a-    put_ bh (Right b) = do putByte bh 1; put_ bh b-    get bh            = do h <- getWord8 bh-                           case h of-                             0 -> do a <- get bh ; return (Left a)-                             _ -> do b <- get bh ; return (Right b)--instance Binary UTCTime where-    put_ bh u = do put_ bh (utctDay u)-                   put_ bh (utctDayTime u)-    get bh = do day <- get bh-                dayTime <- get bh-                return $ UTCTime { utctDay = day, utctDayTime = dayTime }--instance Binary Day where-    put_ bh d = put_ bh (toModifiedJulianDay d)-    get bh = do i <- get bh-                return $ ModifiedJulianDay { toModifiedJulianDay = i }--instance Binary DiffTime where-    put_ bh dt = put_ bh (toRational dt)-    get bh = do r <- get bh-                return $ fromRational r--{--Finally - a reasonable portable Integer instance.--We used to encode values in the Int32 range as such,-falling back to a string of all things. In either case-we stored a tag byte to discriminate between the two cases.--This made some sense as it's highly portable but also not very-efficient.--However GHC stores a surprisingly large number off large Integer-values. In the examples looked at between 25% and 50% of Integers-serialized were outside of the Int32 range.--Consider a valie like `2724268014499746065`, some sort of hash-actually generated by GHC.-In the old scheme this was encoded as a list of 19 chars. This-gave a size of 77 Bytes, one for the length of the list and 76-since we encode chars as Word32 as well.--We can easily do better. The new plan is:--* Start with a tag byte-  * 0 => Int64 (LEB128 encoded)-  * 1 => Negative large interger-  * 2 => Positive large integer-* Followed by the value:-  * Int64 is encoded as usual-  * Large integers are encoded as a list of bytes (Word8).-    We use Data.Bits which defines a bit order independent of the representation.-    Values are stored LSB first.--This means our example value `2724268014499746065` is now only 10 bytes large.-* One byte tag-* One byte for the length of the [Word8] list.-* 8 bytes for the actual date.--The new scheme also does not depend in any way on-architecture specific details.--We still use this scheme even with LEB128 available,-as it has less overhead for truly large numbers. (> maxBound :: Int64)--The instance is used for in Binary Integer and Binary Rational in basicTypes/Literal.hs--}--instance Binary Integer where-    put_ bh i-      | i >= lo64 && i <= hi64 = do-          putWord8 bh 0-          put_ bh (fromIntegral i :: Int64)-      | otherwise = do-          if i < 0-            then putWord8 bh 1-            else putWord8 bh 2-          put_ bh (unroll $ abs i)-      where-        lo64 = fromIntegral (minBound :: Int64)-        hi64 = fromIntegral (maxBound :: Int64)-    get bh = do-      int_kind <- getWord8 bh-      case int_kind of-        0 -> fromIntegral <$!> (get bh :: IO Int64)-        -- Large integer-        1 -> negate <$!> getInt-        2 -> getInt-        _ -> panic "Binary Integer - Invalid byte"-        where-          getInt :: IO Integer-          getInt = roll <$!> (get bh :: IO [Word8])--unroll :: Integer -> [Word8]-unroll = unfoldr step-  where-    step 0 = Nothing-    step i = Just (fromIntegral i, i `shiftR` 8)--roll :: [Word8] -> Integer-roll   = foldl' unstep 0 . reverse-  where-    unstep a b = a `shiftL` 8 .|. fromIntegral b---    {--    -- This code is currently commented out.-    -- See https://gitlab.haskell.org/ghc/ghc/issues/3379#note_104346 for-    -- discussion.--    put_ bh (S# i#) = do putByte bh 0; put_ bh (I# i#)-    put_ bh (J# s# a#) = do-        putByte bh 1-        put_ bh (I# s#)-        let sz# = sizeofByteArray# a#  -- in *bytes*-        put_ bh (I# sz#)  -- in *bytes*-        putByteArray bh a# sz#--    get bh = do-        b <- getByte bh-        case b of-          0 -> do (I# i#) <- get bh-                  return (S# i#)-          _ -> do (I# s#) <- get bh-                  sz <- get bh-                  (BA a#) <- getByteArray bh sz-                  return (J# s# a#)--putByteArray :: BinHandle -> ByteArray# -> Int# -> IO ()-putByteArray bh a s# = loop 0#-  where loop n#-           | n# ==# s# = return ()-           | otherwise = do-                putByte bh (indexByteArray a n#)-                loop (n# +# 1#)--getByteArray :: BinHandle -> Int -> IO ByteArray-getByteArray bh (I# sz) = do-  (MBA arr) <- newByteArray sz-  let loop n-           | n ==# sz = return ()-           | otherwise = do-                w <- getByte bh-                writeByteArray arr n w-                loop (n +# 1#)-  loop 0#-  freezeByteArray arr-    -}--{--data ByteArray = BA ByteArray#-data MBA = MBA (MutableByteArray# RealWorld)--newByteArray :: Int# -> IO MBA-newByteArray sz = IO $ \s ->-  case newByteArray# sz s of { (# s, arr #) ->-  (# s, MBA arr #) }--freezeByteArray :: MutableByteArray# RealWorld -> IO ByteArray-freezeByteArray arr = IO $ \s ->-  case unsafeFreezeByteArray# arr s of { (# s, arr #) ->-  (# s, BA arr #) }--writeByteArray :: MutableByteArray# RealWorld -> Int# -> Word8 -> IO ()-writeByteArray arr i (W8# w) = IO $ \s ->-  case writeWord8Array# arr i w s of { s ->-  (# s, () #) }--indexByteArray :: ByteArray# -> Int# -> Word8-indexByteArray a# n# = W8# (indexWord8Array# a# n#)---}-instance (Binary a) => Binary (Ratio a) where-    put_ bh (a :% b) = do put_ bh a; put_ bh b-    get bh = do a <- get bh; b <- get bh; return (a :% b)---- Instance uses fixed-width encoding to allow inserting--- Bin placeholders in the stream.-instance Binary (Bin a) where-  put_ bh (BinPtr i) = putWord32 bh (fromIntegral i :: Word32)-  get bh = do i <- getWord32 bh; return (BinPtr (fromIntegral (i :: Word32)))---- -------------------------------------------------------------------------------- Instances for Data.Typeable stuff--instance Binary TyCon where-    put_ bh tc = do-        put_ bh (tyConPackage tc)-        put_ bh (tyConModule tc)-        put_ bh (tyConName tc)-        put_ bh (tyConKindArgs tc)-        put_ bh (tyConKindRep tc)-    get bh =-        mkTyCon <$> get bh <*> get bh <*> get bh <*> get bh <*> get bh--instance Binary VecCount where-    put_ bh = putByte bh . fromIntegral . fromEnum-    get bh = toEnum . fromIntegral <$> getByte bh--instance Binary VecElem where-    put_ bh = putByte bh . fromIntegral . fromEnum-    get bh = toEnum . fromIntegral <$> getByte bh--instance Binary RuntimeRep where-    put_ bh (VecRep a b)    = putByte bh 0 >> put_ bh a >> put_ bh b-    put_ bh (TupleRep reps) = putByte bh 1 >> put_ bh reps-    put_ bh (SumRep reps)   = putByte bh 2 >> put_ bh reps-    put_ bh LiftedRep       = putByte bh 3-    put_ bh UnliftedRep     = putByte bh 4-    put_ bh IntRep          = putByte bh 5-    put_ bh WordRep         = putByte bh 6-    put_ bh Int64Rep        = putByte bh 7-    put_ bh Word64Rep       = putByte bh 8-    put_ bh AddrRep         = putByte bh 9-    put_ bh FloatRep        = putByte bh 10-    put_ bh DoubleRep       = putByte bh 11-    put_ bh Int8Rep         = putByte bh 12-    put_ bh Word8Rep        = putByte bh 13-    put_ bh Int16Rep        = putByte bh 14-    put_ bh Word16Rep       = putByte bh 15-#if __GLASGOW_HASKELL__ >= 809-    put_ bh Int32Rep        = putByte bh 16-    put_ bh Word32Rep       = putByte bh 17-#endif--    get bh = do-        tag <- getByte bh-        case tag of-          0  -> VecRep <$> get bh <*> get bh-          1  -> TupleRep <$> get bh-          2  -> SumRep <$> get bh-          3  -> pure LiftedRep-          4  -> pure UnliftedRep-          5  -> pure IntRep-          6  -> pure WordRep-          7  -> pure Int64Rep-          8  -> pure Word64Rep-          9  -> pure AddrRep-          10 -> pure FloatRep-          11 -> pure DoubleRep-          12 -> pure Int8Rep-          13 -> pure Word8Rep-          14 -> pure Int16Rep-          15 -> pure Word16Rep-#if __GLASGOW_HASKELL__ >= 809-          16 -> pure Int32Rep-          17 -> pure Word32Rep-#endif-          _  -> fail "Binary.putRuntimeRep: invalid tag"--instance Binary KindRep where-    put_ bh (KindRepTyConApp tc k) = putByte bh 0 >> put_ bh tc >> put_ bh k-    put_ bh (KindRepVar bndr) = putByte bh 1 >> put_ bh bndr-    put_ bh (KindRepApp a b) = putByte bh 2 >> put_ bh a >> put_ bh b-    put_ bh (KindRepFun a b) = putByte bh 3 >> put_ bh a >> put_ bh b-    put_ bh (KindRepTYPE r) = putByte bh 4 >> put_ bh r-    put_ bh (KindRepTypeLit sort r) = putByte bh 5 >> put_ bh sort >> put_ bh r--    get bh = do-        tag <- getByte bh-        case tag of-          0 -> KindRepTyConApp <$> get bh <*> get bh-          1 -> KindRepVar <$> get bh-          2 -> KindRepApp <$> get bh <*> get bh-          3 -> KindRepFun <$> get bh <*> get bh-          4 -> KindRepTYPE <$> get bh-          5 -> KindRepTypeLit <$> get bh <*> get bh-          _ -> fail "Binary.putKindRep: invalid tag"--instance Binary TypeLitSort where-    put_ bh TypeLitSymbol = putByte bh 0-    put_ bh TypeLitNat = putByte bh 1-    get bh = do-        tag <- getByte bh-        case tag of-          0 -> pure TypeLitSymbol-          1 -> pure TypeLitNat-          _ -> fail "Binary.putTypeLitSort: invalid tag"--putTypeRep :: BinHandle -> TypeRep a -> IO ()--- Special handling for TYPE, (->), and RuntimeRep due to recursive kind--- relations.--- See Note [Mutually recursive representations of primitive types]-putTypeRep bh rep-  | Just HRefl <- rep `eqTypeRep` (typeRep :: TypeRep Type)-  = put_ bh (0 :: Word8)-putTypeRep bh (Con' con ks) = do-    put_ bh (1 :: Word8)-    put_ bh con-    put_ bh ks-putTypeRep bh (App f x) = do-    put_ bh (2 :: Word8)-    putTypeRep bh f-    putTypeRep bh x-putTypeRep bh (Fun arg res) = do-    put_ bh (3 :: Word8)-    putTypeRep bh arg-    putTypeRep bh res--getSomeTypeRep :: BinHandle -> IO SomeTypeRep-getSomeTypeRep bh = do-    tag <- get bh :: IO Word8-    case tag of-        0 -> return $ SomeTypeRep (typeRep :: TypeRep Type)-        1 -> do con <- get bh :: IO TyCon-                ks <- get bh :: IO [SomeTypeRep]-                return $ SomeTypeRep $ mkTrCon con ks--        2 -> do SomeTypeRep f <- getSomeTypeRep bh-                SomeTypeRep x <- getSomeTypeRep bh-                case typeRepKind f of-                  Fun arg res ->-                      case arg `eqTypeRep` typeRepKind x of-                        Just HRefl ->-                            case typeRepKind res `eqTypeRep` (typeRep :: TypeRep Type) of-                              Just HRefl -> return $ SomeTypeRep $ mkTrApp f x-                              _ -> failure "Kind mismatch in type application" []-                        _ -> failure "Kind mismatch in type application"-                             [ "    Found argument of kind: " ++ show (typeRepKind x)-                             , "    Where the constructor:  " ++ show f-                             , "    Expects kind:           " ++ show arg-                             ]-                  _ -> failure "Applied non-arrow"-                       [ "    Applied type: " ++ show f-                       , "    To argument:  " ++ show x-                       ]-        3 -> do SomeTypeRep arg <- getSomeTypeRep bh-                SomeTypeRep res <- getSomeTypeRep bh-                if-                  | App argkcon _ <- typeRepKind arg-                  , App reskcon _ <- typeRepKind res-                  , Just HRefl <- argkcon `eqTypeRep` tYPErep-                  , Just HRefl <- reskcon `eqTypeRep` tYPErep-                  -> return $ SomeTypeRep $ Fun arg res-                  | otherwise -> failure "Kind mismatch" []-        _ -> failure "Invalid SomeTypeRep" []-  where-    tYPErep :: TypeRep TYPE-    tYPErep = typeRep--    failure description info =-        fail $ unlines $ [ "Binary.getSomeTypeRep: "++description ]-                      ++ map ("    "++) info--instance Typeable a => Binary (TypeRep (a :: k)) where-    put_ = putTypeRep-    get bh = do-        SomeTypeRep rep <- getSomeTypeRep bh-        case rep `eqTypeRep` expected of-            Just HRefl -> pure rep-            Nothing    -> fail $ unlines-                               [ "Binary: Type mismatch"-                               , "    Deserialized type: " ++ show rep-                               , "    Expected type:     " ++ show expected-                               ]-     where expected = typeRep :: TypeRep a--instance Binary SomeTypeRep where-    put_ bh (SomeTypeRep rep) = putTypeRep bh rep-    get = getSomeTypeRep---- -------------------------------------------------------------------------------- Lazy reading/writing--lazyPut :: Binary a => BinHandle -> a -> IO ()-lazyPut bh a = do-    -- output the obj with a ptr to skip over it:-    pre_a <- tellBin bh-    put_ bh pre_a       -- save a slot for the ptr-    put_ bh a           -- dump the object-    q <- tellBin bh     -- q = ptr to after object-    putAt bh pre_a q    -- fill in slot before a with ptr to q-    seekBin bh q        -- finally carry on writing at q--lazyGet :: Binary a => BinHandle -> IO a-lazyGet bh = do-    p <- get bh -- a BinPtr-    p_a <- tellBin bh-    a <- unsafeInterleaveIO $ do-        -- NB: Use a fresh off_r variable in the child thread, for thread-        -- safety.-        off_r <- newFastMutInt-        getAt bh { _off_r = off_r } p_a-    seekBin bh p -- skip over the object for now-    return a---- -------------------------------------------------------------------------------- UserData--- --------------------------------------------------------------------------------- | Information we keep around during interface file--- serialization/deserialization. Namely we keep the functions for serializing--- and deserializing 'Name's and 'FastString's. We do this because we actually--- use serialization in two distinct settings,------ * When serializing interface files themselves------ * When computing the fingerprint of an IfaceDecl (which we computing by---   hashing its Binary serialization)------ These two settings have different needs while serializing Names:------ * Names in interface files are serialized via a symbol table (see Note---   [Symbol table representation of names] in GHC.Iface.Binary).------ * During fingerprinting a binding Name is serialized as the OccName and a---   non-binding Name is serialized as the fingerprint of the thing they---   represent. See Note [Fingerprinting IfaceDecls] for further discussion.----data UserData =-   UserData {-        -- for *deserialising* only:-        ud_get_name :: BinHandle -> IO Name,-        ud_get_fs   :: BinHandle -> IO FastString,--        -- for *serialising* only:-        ud_put_nonbinding_name :: BinHandle -> Name -> IO (),-        -- ^ serialize a non-binding 'Name' (e.g. a reference to another-        -- binding).-        ud_put_binding_name :: BinHandle -> Name -> IO (),-        -- ^ serialize a binding 'Name' (e.g. the name of an IfaceDecl)-        ud_put_fs   :: BinHandle -> FastString -> IO ()-   }--newReadState :: (BinHandle -> IO Name)   -- ^ how to deserialize 'Name's-             -> (BinHandle -> IO FastString)-             -> UserData-newReadState get_name get_fs-  = UserData { ud_get_name = get_name,-               ud_get_fs   = get_fs,-               ud_put_nonbinding_name = undef "put_nonbinding_name",-               ud_put_binding_name    = undef "put_binding_name",-               ud_put_fs   = undef "put_fs"-             }--newWriteState :: (BinHandle -> Name -> IO ())-                 -- ^ how to serialize non-binding 'Name's-              -> (BinHandle -> Name -> IO ())-                 -- ^ how to serialize binding 'Name's-              -> (BinHandle -> FastString -> IO ())-              -> UserData-newWriteState put_nonbinding_name put_binding_name put_fs-  = UserData { ud_get_name = undef "get_name",-               ud_get_fs   = undef "get_fs",-               ud_put_nonbinding_name = put_nonbinding_name,-               ud_put_binding_name    = put_binding_name,-               ud_put_fs   = put_fs-             }--noUserData :: a-noUserData = undef "UserData"--undef :: String -> a-undef s = panic ("Binary.UserData: no " ++ s)-------------------------------------------------------------- The Dictionary------------------------------------------------------------type Dictionary = Array Int FastString -- The dictionary-                                       -- Should be 0-indexed--putDictionary :: BinHandle -> Int -> UniqFM (Int,FastString) -> IO ()-putDictionary bh sz dict = do-  put_ bh sz-  mapM_ (putFS bh) (elems (array (0,sz-1) (nonDetEltsUFM dict)))-    -- It's OK to use nonDetEltsUFM here because the elements have indices-    -- that array uses to create order--getDictionary :: BinHandle -> IO Dictionary-getDictionary bh = do-  sz <- get bh-  elems <- sequence (take sz (repeat (getFS bh)))-  return (listArray (0,sz-1) elems)-------------------------------------------------------------- The Symbol Table-------------------------------------------------------------- On disk, the symbol table is an array of IfExtName, when--- reading it in we turn it into a SymbolTable.--type SymbolTable = Array Int Name-------------------------------------------------------------- Reading and writing FastStrings------------------------------------------------------------putFS :: BinHandle -> FastString -> IO ()-putFS bh fs = putBS bh $ bytesFS fs--getFS :: BinHandle -> IO FastString-getFS bh = do-  l  <- get bh :: IO Int-  getPrim bh l (\src -> pure $! mkFastStringBytes src l )--putBS :: BinHandle -> ByteString -> IO ()-putBS bh bs =-  BS.unsafeUseAsCStringLen bs $ \(ptr, l) -> do-    put_ bh l-    putPrim bh l (\op -> BS.memcpy op (castPtr ptr) l)--getBS :: BinHandle -> IO ByteString-getBS bh = do-  l <- get bh :: IO Int-  BS.create l $ \dest -> do-    getPrim bh l (\src -> BS.memcpy dest src l)--instance Binary ByteString where-  put_ bh f = putBS bh f-  get bh = getBS bh--instance Binary FastString where-  put_ bh f =-    case getUserData bh of-        UserData { ud_put_fs = put_fs } -> put_fs bh f--  get bh =-    case getUserData bh of-        UserData { ud_get_fs = get_fs } -> get_fs bh---- Here to avoid loop-instance Binary LeftOrRight where-   put_ bh CLeft  = putByte bh 0-   put_ bh CRight = putByte bh 1--   get bh = do { h <- getByte bh-               ; case h of-                   0 -> return CLeft-                   _ -> return CRight }--instance Binary PromotionFlag where-   put_ bh NotPromoted = putByte bh 0-   put_ bh IsPromoted  = putByte bh 1--   get bh = do-       n <- getByte bh-       case n of-         0 -> return NotPromoted-         1 -> return IsPromoted-         _ -> fail "Binary(IsPromoted): fail)"--instance Binary Fingerprint where-  put_ h (Fingerprint w1 w2) = do put_ h w1; put_ h w2-  get  h = do w1 <- get h; w2 <- get h; return (Fingerprint w1 w2)--instance Binary FunctionOrData where-    put_ bh IsFunction = putByte bh 0-    put_ bh IsData     = putByte bh 1-    get bh = do-        h <- getByte bh-        case h of-          0 -> return IsFunction-          1 -> return IsData-          _ -> panic "Binary FunctionOrData"--instance Binary TupleSort where-    put_ bh BoxedTuple      = putByte bh 0-    put_ bh UnboxedTuple    = putByte bh 1-    put_ bh ConstraintTuple = putByte bh 2-    get bh = do-      h <- getByte bh-      case h of-        0 -> do return BoxedTuple-        1 -> do return UnboxedTuple-        _ -> do return ConstraintTuple--instance Binary Activation where-    put_ bh NeverActive = do-            putByte bh 0-    put_ bh AlwaysActive = do-            putByte bh 1-    put_ bh (ActiveBefore src aa) = do-            putByte bh 2-            put_ bh src-            put_ bh aa-    put_ bh (ActiveAfter src ab) = do-            putByte bh 3-            put_ bh src-            put_ bh ab-    get bh = do-            h <- getByte bh-            case h of-              0 -> do return NeverActive-              1 -> do return AlwaysActive-              2 -> do src <- get bh-                      aa <- get bh-                      return (ActiveBefore src aa)-              _ -> do src <- get bh-                      ab <- get bh-                      return (ActiveAfter src ab)--instance Binary InlinePragma where-    put_ bh (InlinePragma s a b c d) = do-            put_ bh s-            put_ bh a-            put_ bh b-            put_ bh c-            put_ bh d--    get bh = do-           s <- get bh-           a <- get bh-           b <- get bh-           c <- get bh-           d <- get bh-           return (InlinePragma s a b c d)--instance Binary RuleMatchInfo where-    put_ bh FunLike = putByte bh 0-    put_ bh ConLike = putByte bh 1-    get bh = do-            h <- getByte bh-            if h == 1 then return ConLike-                      else return FunLike--instance Binary InlineSpec where-    put_ bh NoUserInline    = putByte bh 0-    put_ bh Inline          = putByte bh 1-    put_ bh Inlinable       = putByte bh 2-    put_ bh NoInline        = putByte bh 3--    get bh = do h <- getByte bh-                case h of-                  0 -> return NoUserInline-                  1 -> return Inline-                  2 -> return Inlinable-                  _ -> return NoInline--instance Binary RecFlag where-    put_ bh Recursive = do-            putByte bh 0-    put_ bh NonRecursive = do-            putByte bh 1-    get bh = do-            h <- getByte bh-            case h of-              0 -> do return Recursive-              _ -> do return NonRecursive--instance Binary OverlapMode where-    put_ bh (NoOverlap    s) = putByte bh 0 >> put_ bh s-    put_ bh (Overlaps     s) = putByte bh 1 >> put_ bh s-    put_ bh (Incoherent   s) = putByte bh 2 >> put_ bh s-    put_ bh (Overlapping  s) = putByte bh 3 >> put_ bh s-    put_ bh (Overlappable s) = putByte bh 4 >> put_ bh s-    get bh = do-        h <- getByte bh-        case h of-            0 -> (get bh) >>= \s -> return $ NoOverlap s-            1 -> (get bh) >>= \s -> return $ Overlaps s-            2 -> (get bh) >>= \s -> return $ Incoherent s-            3 -> (get bh) >>= \s -> return $ Overlapping s-            4 -> (get bh) >>= \s -> return $ Overlappable s-            _ -> panic ("get OverlapMode" ++ show h)---instance Binary OverlapFlag where-    put_ bh flag = do put_ bh (overlapMode flag)-                      put_ bh (isSafeOverlap flag)-    get bh = do-        h <- get bh-        b <- get bh-        return OverlapFlag { overlapMode = h, isSafeOverlap = b }--instance Binary FixityDirection where-    put_ bh InfixL = do-            putByte bh 0-    put_ bh InfixR = do-            putByte bh 1-    put_ bh InfixN = do-            putByte bh 2-    get bh = do-            h <- getByte bh-            case h of-              0 -> do return InfixL-              1 -> do return InfixR-              _ -> do return InfixN--instance Binary Fixity where-    put_ bh (Fixity src aa ab) = do-            put_ bh src-            put_ bh aa-            put_ bh ab-    get bh = do-          src <- get bh-          aa <- get bh-          ab <- get bh-          return (Fixity src aa ab)--instance Binary WarningTxt where-    put_ bh (WarningTxt s w) = do-            putByte bh 0-            put_ bh s-            put_ bh w-    put_ bh (DeprecatedTxt s d) = do-            putByte bh 1-            put_ bh s-            put_ bh d--    get bh = do-            h <- getByte bh-            case h of-              0 -> do s <- get bh-                      w <- get bh-                      return (WarningTxt s w)-              _ -> do s <- get bh-                      d <- get bh-                      return (DeprecatedTxt s d)--instance Binary StringLiteral where-  put_ bh (StringLiteral st fs) = do-            put_ bh st-            put_ bh fs-  get bh = do-            st <- get bh-            fs <- get bh-            return (StringLiteral st fs)--instance Binary a => Binary (Located a) where-    put_ bh (L l x) = do-            put_ bh l-            put_ bh x--    get bh = do-            l <- get bh-            x <- get bh-            return (L l x)--instance Binary RealSrcSpan where-  put_ bh ss = do-            put_ bh (srcSpanFile ss)-            put_ bh (srcSpanStartLine ss)-            put_ bh (srcSpanStartCol ss)-            put_ bh (srcSpanEndLine ss)-            put_ bh (srcSpanEndCol ss)--  get bh = do-            f <- get bh-            sl <- get bh-            sc <- get bh-            el <- get bh-            ec <- get bh-            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 sb) = do-          putByte bh 0-          put_ bh ss-          put_ bh sb--  put_ bh (UnhelpfulSpan s) = do-          putByte bh 1-          put_ bh s--  get bh = do-          h <- getByte bh-          case h of-            0 -> do ss <- get bh-                    sb <- get bh-                    return (RealSrcSpan ss sb)-            _ -> do s <- get bh-                    return (UnhelpfulSpan s)--instance Binary Serialized where-    put_ bh (Serialized the_type bytes) = do-        put_ bh the_type-        put_ bh bytes-    get bh = do-        the_type <- get bh-        bytes <- get bh-        return (Serialized the_type bytes)--instance Binary SourceText where-  put_ bh NoSourceText = putByte bh 0-  put_ bh (SourceText s) = do-        putByte bh 1-        put_ bh s--  get bh = do-    h <- getByte bh-    case h of-      0 -> return NoSourceText-      1 -> do-        s <- get bh-        return (SourceText s)-      _ -> panic $ "Binary SourceText:" ++ show h
− compiler/utils/BooleanFormula.hs 
@@ -1,262 +0,0 @@-{-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable,-             DeriveTraversable #-}------------------------------------------------------------------------------------- | Boolean formulas without quantifiers and without negation.--- Such a formula consists of variables, conjunctions (and), and disjunctions (or).------ This module is used to represent minimal complete definitions for classes.----module BooleanFormula (-        BooleanFormula(..), LBooleanFormula,-        mkFalse, mkTrue, mkAnd, mkOr, mkVar,-        isFalse, isTrue,-        eval, simplify, isUnsatisfied,-        implies, impliesAtom,-        pprBooleanFormula, pprBooleanFormulaNice-  ) where--import GhcPrelude--import Data.List ( nub, intersperse )-import Data.Data--import MonadUtils-import Outputable-import Binary-import GHC.Types.SrcLoc-import GHC.Types.Unique-import GHC.Types.Unique.Set--------------------------------------------------------------------------- Boolean formula type and smart constructors-------------------------------------------------------------------------type LBooleanFormula a = Located (BooleanFormula a)--data BooleanFormula a = Var a | And [LBooleanFormula a] | Or [LBooleanFormula a]-                      | Parens (LBooleanFormula a)-  deriving (Eq, Data, Functor, Foldable, Traversable)--mkVar :: a -> BooleanFormula a-mkVar = Var--mkFalse, mkTrue :: BooleanFormula a-mkFalse = Or []-mkTrue = And []---- Convert a Bool to a BooleanFormula-mkBool :: Bool -> BooleanFormula a-mkBool False = mkFalse-mkBool True  = mkTrue---- Make a conjunction, and try to simplify-mkAnd :: Eq a => [LBooleanFormula a] -> BooleanFormula a-mkAnd = maybe mkFalse (mkAnd' . nub) . concatMapM fromAnd-  where-  -- See Note [Simplification of BooleanFormulas]-  fromAnd :: LBooleanFormula a -> Maybe [LBooleanFormula a]-  fromAnd (L _ (And xs)) = Just xs-     -- assume that xs are already simplified-     -- otherwise we would need: fromAnd (And xs) = concat <$> traverse fromAnd xs-  fromAnd (L _ (Or [])) = Nothing-     -- in case of False we bail out, And [..,mkFalse,..] == mkFalse-  fromAnd x = Just [x]-  mkAnd' [x] = unLoc x-  mkAnd' xs = And xs--mkOr :: Eq a => [LBooleanFormula a] -> BooleanFormula a-mkOr = maybe mkTrue (mkOr' . nub) . concatMapM fromOr-  where-  -- See Note [Simplification of BooleanFormulas]-  fromOr (L _ (Or xs)) = Just xs-  fromOr (L _ (And [])) = Nothing-  fromOr x = Just [x]-  mkOr' [x] = unLoc x-  mkOr' xs = Or xs---{--Note [Simplification of BooleanFormulas]-~~~~~~~~~~~~~~~~~~~~~~-The smart constructors (`mkAnd` and `mkOr`) do some attempt to simplify expressions. In particular,- 1. Collapsing nested ands and ors, so-     `(mkAnd [x, And [y,z]]`-    is represented as-     `And [x,y,z]`-    Implemented by `fromAnd`/`fromOr`- 2. Collapsing trivial ands and ors, so-     `mkAnd [x]` becomes just `x`.-    Implemented by mkAnd' / mkOr'- 3. Conjunction with false, disjunction with true is simplified, i.e.-     `mkAnd [mkFalse,x]` becomes `mkFalse`.- 4. Common subexpression elimination:-     `mkAnd [x,x,y]` is reduced to just `mkAnd [x,y]`.--This simplification is not exhaustive, in the sense that it will not produce-the smallest possible equivalent expression. For example,-`Or [And [x,y], And [x]]` could be simplified to `And [x]`, but it currently-is not. A general simplifier would need to use something like BDDs.--The reason behind the (crude) simplifier is to make for more user friendly-error messages. E.g. for the code-  > class Foo a where-  >     {-# MINIMAL bar, (foo, baq | foo, quux) #-}-  > instance Foo Int where-  >     bar = ...-  >     baz = ...-  >     quux = ...-We don't show a ridiculous error message like-    Implement () and (either (`foo' and ()) or (`foo' and ()))--}--------------------------------------------------------------------------- Evaluation and simplification-------------------------------------------------------------------------isFalse :: BooleanFormula a -> Bool-isFalse (Or []) = True-isFalse _ = False--isTrue :: BooleanFormula a -> Bool-isTrue (And []) = True-isTrue _ = False--eval :: (a -> Bool) -> BooleanFormula a -> Bool-eval f (Var x)  = f x-eval f (And xs) = all (eval f . unLoc) xs-eval f (Or xs)  = any (eval f . unLoc) xs-eval f (Parens x) = eval f (unLoc x)---- Simplify a boolean formula.--- The argument function should give the truth of the atoms, or Nothing if undecided.-simplify :: Eq a => (a -> Maybe Bool) -> BooleanFormula a -> BooleanFormula a-simplify f (Var a) = case f a of-  Nothing -> Var a-  Just b  -> mkBool b-simplify f (And xs) = mkAnd (map (\(L l x) -> L l (simplify f x)) xs)-simplify f (Or xs) = mkOr (map (\(L l x) -> L l (simplify f x)) xs)-simplify f (Parens x) = simplify f (unLoc x)---- Test if a boolean formula is satisfied when the given values are assigned to the atoms--- if it is, returns Nothing--- if it is not, return (Just remainder)-isUnsatisfied :: Eq a => (a -> Bool) -> BooleanFormula a -> Maybe (BooleanFormula a)-isUnsatisfied f bf-    | isTrue bf' = Nothing-    | otherwise  = Just bf'-  where-  f' x = if f x then Just True else Nothing-  bf' = simplify f' bf---- prop_simplify:---   eval f x == True   <==>  isTrue  (simplify (Just . f) x)---   eval f x == False  <==>  isFalse (simplify (Just . f) x)---- If the boolean formula holds, does that mean that the given atom is always true?-impliesAtom :: Eq a => BooleanFormula a -> a -> Bool-Var x  `impliesAtom` y = x == y-And xs `impliesAtom` y = any (\x -> (unLoc x) `impliesAtom` y) xs-           -- we have all of xs, so one of them implying y is enough-Or  xs `impliesAtom` y = all (\x -> (unLoc x) `impliesAtom` y) xs-Parens x `impliesAtom` y = (unLoc x) `impliesAtom` y--implies :: Uniquable a => BooleanFormula a -> BooleanFormula a -> Bool-implies e1 e2 = go (Clause emptyUniqSet [e1]) (Clause emptyUniqSet [e2])-  where-    go :: Uniquable a => Clause a -> Clause a -> Bool-    go l@Clause{ clauseExprs = hyp:hyps } r =-        case hyp of-            Var x | memberClauseAtoms x r -> True-                  | otherwise -> go (extendClauseAtoms l x) { clauseExprs = hyps } r-            Parens hyp' -> go l { clauseExprs = unLoc hyp':hyps }     r-            And hyps'  -> go l { clauseExprs = map unLoc hyps' ++ hyps } r-            Or hyps'   -> all (\hyp' -> go l { clauseExprs = unLoc hyp':hyps } r) hyps'-    go l r@Clause{ clauseExprs = con:cons } =-        case con of-            Var x | memberClauseAtoms x l -> True-                  | otherwise -> go l (extendClauseAtoms r x) { clauseExprs = cons }-            Parens con' -> go l r { clauseExprs = unLoc con':cons }-            And cons'   -> all (\con' -> go l r { clauseExprs = unLoc con':cons }) cons'-            Or cons'    -> go l r { clauseExprs = map unLoc cons' ++ cons }-    go _ _ = False---- A small sequent calculus proof engine.-data Clause a = Clause {-        clauseAtoms :: UniqSet a,-        clauseExprs :: [BooleanFormula a]-    }-extendClauseAtoms :: Uniquable a => Clause a -> a -> Clause a-extendClauseAtoms c x = c { clauseAtoms = addOneToUniqSet (clauseAtoms c) x }--memberClauseAtoms :: Uniquable a => a -> Clause a -> Bool-memberClauseAtoms x c = x `elementOfUniqSet` clauseAtoms c--------------------------------------------------------------------------- Pretty printing--------------------------------------------------------------------------- Pretty print a BooleanFormula,--- using the arguments as pretty printers for Var, And and Or respectively-pprBooleanFormula' :: (Rational -> a -> SDoc)-                   -> (Rational -> [SDoc] -> SDoc)-                   -> (Rational -> [SDoc] -> SDoc)-                   -> Rational -> BooleanFormula a -> SDoc-pprBooleanFormula' pprVar pprAnd pprOr = go-  where-  go p (Var x)  = pprVar p x-  go p (And []) = cparen (p > 0) $ empty-  go p (And xs) = pprAnd p (map (go 3 . unLoc) xs)-  go _ (Or  []) = keyword $ text "FALSE"-  go p (Or  xs) = pprOr p (map (go 2 . unLoc) xs)-  go p (Parens x) = go p (unLoc x)---- Pretty print in source syntax, "a | b | c,d,e"-pprBooleanFormula :: (Rational -> a -> SDoc) -> Rational -> BooleanFormula a -> SDoc-pprBooleanFormula pprVar = pprBooleanFormula' pprVar pprAnd pprOr-  where-  pprAnd p = cparen (p > 3) . fsep . punctuate comma-  pprOr  p = cparen (p > 2) . fsep . intersperse vbar---- Pretty print human in readable format, "either `a' or `b' or (`c', `d' and `e')"?-pprBooleanFormulaNice :: Outputable a => BooleanFormula a -> SDoc-pprBooleanFormulaNice = pprBooleanFormula' pprVar pprAnd pprOr 0-  where-  pprVar _ = quotes . ppr-  pprAnd p = cparen (p > 1) . pprAnd'-  pprAnd' [] = empty-  pprAnd' [x,y] = x <+> text "and" <+> y-  pprAnd' xs@(_:_) = fsep (punctuate comma (init xs)) <> text ", and" <+> last xs-  pprOr p xs = cparen (p > 1) $ text "either" <+> sep (intersperse (text "or") xs)--instance (OutputableBndr a) => Outputable (BooleanFormula a) where-  ppr = pprBooleanFormulaNormal--pprBooleanFormulaNormal :: (OutputableBndr a)-                        => BooleanFormula a -> SDoc-pprBooleanFormulaNormal = go-  where-    go (Var x)    = pprPrefixOcc x-    go (And xs)   = fsep $ punctuate comma (map (go . unLoc) xs)-    go (Or [])    = keyword $ text "FALSE"-    go (Or xs)    = fsep $ intersperse vbar (map (go . unLoc) xs)-    go (Parens x) = parens (go $ unLoc x)---------------------------------------------------------------------------- Binary-------------------------------------------------------------------------instance Binary a => Binary (BooleanFormula a) where-  put_ bh (Var x)    = putByte bh 0 >> put_ bh x-  put_ bh (And xs)   = putByte bh 1 >> put_ bh xs-  put_ bh (Or  xs)   = putByte bh 2 >> put_ bh xs-  put_ bh (Parens x) = putByte bh 3 >> put_ bh x--  get bh = do-    h <- getByte bh-    case h of-      0 -> Var    <$> get bh-      1 -> And    <$> get bh-      2 -> Or     <$> get bh-      _ -> Parens <$> get bh
− compiler/utils/BufWrite.hs 
@@ -1,145 +0,0 @@-{-# LANGUAGE BangPatterns #-}------------------------------------------------------------------------------------- Fast write-buffered Handles------ (c) The University of Glasgow 2005-2006------ This is a simple abstraction over Handles that offers very fast write--- buffering, but without the thread safety that Handles provide.  It's used--- to save time in Pretty.printDoc.-----------------------------------------------------------------------------------module BufWrite (-        BufHandle(..),-        newBufHandle,-        bPutChar,-        bPutStr,-        bPutFS,-        bPutFZS,-        bPutPtrString,-        bPutReplicate,-        bFlush,-  ) where--import GhcPrelude--import FastString-import FastMutInt--import Control.Monad    ( when )-import Data.ByteString (ByteString)-import qualified Data.ByteString.Unsafe as BS-import Data.Char        ( ord )-import Foreign-import Foreign.C.String-import System.IO---- -------------------------------------------------------------------------------data BufHandle = BufHandle {-#UNPACK#-}!(Ptr Word8)-                           {-#UNPACK#-}!FastMutInt-                           Handle--newBufHandle :: Handle -> IO BufHandle-newBufHandle hdl = do-  ptr <- mallocBytes buf_size-  r <- newFastMutInt-  writeFastMutInt r 0-  return (BufHandle ptr r hdl)--buf_size :: Int-buf_size = 8192--bPutChar :: BufHandle -> Char -> IO ()-bPutChar b@(BufHandle buf r hdl) !c = do-  i <- readFastMutInt r-  if (i >= buf_size)-        then do hPutBuf hdl buf buf_size-                writeFastMutInt r 0-                bPutChar b c-        else do pokeElemOff buf i (fromIntegral (ord c) :: Word8)-                writeFastMutInt r (i+1)--bPutStr :: BufHandle -> String -> IO ()-bPutStr (BufHandle buf r hdl) !str = do-  i <- readFastMutInt r-  loop str i-  where loop "" !i = do writeFastMutInt r i; return ()-        loop (c:cs) !i-           | i >= buf_size = do-                hPutBuf hdl buf buf_size-                loop (c:cs) 0-           | otherwise = do-                pokeElemOff buf i (fromIntegral (ord c))-                loop cs (i+1)--bPutFS :: BufHandle -> FastString -> IO ()-bPutFS b fs = bPutBS b $ bytesFS fs--bPutFZS :: BufHandle -> FastZString -> IO ()-bPutFZS b fs = bPutBS b $ fastZStringToByteString fs--bPutBS :: BufHandle -> ByteString -> IO ()-bPutBS b bs = BS.unsafeUseAsCStringLen bs $ bPutCStringLen b--bPutCStringLen :: BufHandle -> CStringLen -> IO ()-bPutCStringLen b@(BufHandle buf r hdl) cstr@(ptr, len) = do-  i <- readFastMutInt r-  if (i + len) >= buf_size-        then do hPutBuf hdl buf i-                writeFastMutInt r 0-                if (len >= buf_size)-                    then hPutBuf hdl ptr len-                    else bPutCStringLen b cstr-        else do-                copyBytes (buf `plusPtr` i) ptr len-                writeFastMutInt r (i + len)--bPutPtrString :: BufHandle -> PtrString -> IO ()-bPutPtrString b@(BufHandle buf r hdl) l@(PtrString a len) = l `seq` do-  i <- readFastMutInt r-  if (i+len) >= buf_size-        then do hPutBuf hdl buf i-                writeFastMutInt r 0-                if (len >= buf_size)-                    then hPutBuf hdl a len-                    else bPutPtrString b l-        else do-                copyBytes (buf `plusPtr` i) a len-                writeFastMutInt r (i+len)---- | Replicate an 8-bit character-bPutReplicate :: BufHandle -> Int -> Char -> IO ()-bPutReplicate (BufHandle buf r hdl) len c = do-  i <- readFastMutInt r-  let oc = fromIntegral (ord c)-  if (i+len) < buf_size-    then do-      fillBytes (buf `plusPtr` i) oc len-      writeFastMutInt r (i+len)-    else do-      -- flush the current buffer-      when (i /= 0) $ hPutBuf hdl buf i-      if (len < buf_size)-        then do-          fillBytes buf oc len-          writeFastMutInt r len-        else do-          -- fill a full buffer-          fillBytes buf oc buf_size-          -- flush it as many times as necessary-          let go n | n >= buf_size = do-                                       hPutBuf hdl buf buf_size-                                       go (n-buf_size)-                   | otherwise     = writeFastMutInt r n-          go len--bFlush :: BufHandle -> IO ()-bFlush (BufHandle buf r hdl) = do-  i <- readFastMutInt r-  when (i > 0) $ hPutBuf hdl buf i-  free buf-  return ()
− compiler/utils/Digraph.hs 
@@ -1,524 +0,0 @@--- (c) The University of Glasgow 2006--{-# LANGUAGE CPP, ScopedTypeVariables, ViewPatterns #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}--module Digraph(-        Graph, graphFromEdgedVerticesOrd, graphFromEdgedVerticesUniq,--        SCC(..), Node(..), flattenSCC, flattenSCCs,-        stronglyConnCompG,-        topologicalSortG,-        verticesG, edgesG, hasVertexG,-        reachableG, reachablesG, transposeG,-        emptyG,--        findCycle,--        -- For backwards compatibility with the simpler version of Digraph-        stronglyConnCompFromEdgedVerticesOrd,-        stronglyConnCompFromEdgedVerticesOrdR,-        stronglyConnCompFromEdgedVerticesUniq,-        stronglyConnCompFromEdgedVerticesUniqR,--        -- Simple way to classify edges-        EdgeType(..), classifyEdges-    ) where--#include "HsVersions.h"----------------------------------------------------------------------------------- A version of the graph algorithms described in:------ ``Lazy Depth-First Search and Linear IntGraph Algorithms in Haskell''---   by David King and John Launchbury------ Also included is some additional code for printing tree structures ...------ If you ever find yourself in need of algorithms for classifying edges,--- or finding connected/biconnected components, consult the history; Sigbjorn--- Finne contributed some implementations in 1997, although we've since--- removed them since they were not used anywhere in GHC.----------------------------------------------------------------------------------import GhcPrelude--import Util        ( minWith, count )-import Outputable-import Maybes      ( expectJust )---- std interfaces-import Data.Maybe-import Data.Array-import Data.List hiding (transpose)-import qualified Data.Map as Map-import qualified Data.Set as Set--import qualified Data.Graph as G-import Data.Graph hiding (Graph, Edge, transposeG, reachable)-import Data.Tree-import GHC.Types.Unique-import GHC.Types.Unique.FM--{--************************************************************************-*                                                                      *-*      Graphs and Graph Construction-*                                                                      *-************************************************************************--Note [Nodes, keys, vertices]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~- * A 'node' is a big blob of client-stuff-- * Each 'node' has a unique (client) 'key', but the latter-        is in Ord and has fast comparison-- * Digraph then maps each 'key' to a Vertex (Int) which is-        arranged densely in 0.n--}--data Graph node = Graph {-    gr_int_graph      :: IntGraph,-    gr_vertex_to_node :: Vertex -> node,-    gr_node_to_vertex :: node -> Maybe Vertex-  }--data Edge node = Edge node node--{-| Representation for nodes of the Graph.-- * The @payload@ is user data, just carried around in this module-- * The @key@ is the node identifier.-   Key has an Ord instance for performance reasons.-- * The @[key]@ are the dependencies of the node;-   it's ok to have extra keys in the dependencies that-   are not the key of any Node in the graph--}-data Node key payload = DigraphNode {-      node_payload :: payload, -- ^ User data-      node_key :: key, -- ^ User defined node id-      node_dependencies :: [key] -- ^ Dependencies/successors of the node-  }---instance (Outputable a, Outputable b) => Outputable (Node  a b) where-  ppr (DigraphNode a b c) = ppr (a, b, c)--emptyGraph :: Graph a-emptyGraph = Graph (array (1, 0) []) (error "emptyGraph") (const Nothing)---- See Note [Deterministic SCC]-graphFromEdgedVertices-        :: ReduceFn key payload-        -> [Node key payload]           -- The graph; its ok for the-                                        -- out-list to contain keys which aren't-                                        -- a vertex key, they are ignored-        -> Graph (Node key payload)-graphFromEdgedVertices _reduceFn []            = emptyGraph-graphFromEdgedVertices reduceFn edged_vertices =-  Graph graph vertex_fn (key_vertex . key_extractor)-  where key_extractor = node_key-        (bounds, vertex_fn, key_vertex, numbered_nodes) =-          reduceFn edged_vertices key_extractor-        graph = array bounds [ (v, sort $ mapMaybe key_vertex ks)-                             | (v, (node_dependencies -> ks)) <- numbered_nodes]-                -- We normalize outgoing edges by sorting on node order, so-                -- that the result doesn't depend on the order of the edges---- See Note [Deterministic SCC]--- See Note [reduceNodesIntoVertices implementations]-graphFromEdgedVerticesOrd-        :: Ord key-        => [Node key payload]           -- The graph; its ok for the-                                        -- out-list to contain keys which aren't-                                        -- a vertex key, they are ignored-        -> Graph (Node key payload)-graphFromEdgedVerticesOrd = graphFromEdgedVertices reduceNodesIntoVerticesOrd---- See Note [Deterministic SCC]--- See Note [reduceNodesIntoVertices implementations]-graphFromEdgedVerticesUniq-        :: Uniquable key-        => [Node key payload]           -- The graph; its ok for the-                                        -- out-list to contain keys which aren't-                                        -- a vertex key, they are ignored-        -> Graph (Node key payload)-graphFromEdgedVerticesUniq = graphFromEdgedVertices reduceNodesIntoVerticesUniq--type ReduceFn key payload =-  [Node key payload] -> (Node key payload -> key) ->-    (Bounds, Vertex -> Node key payload-    , key -> Maybe Vertex, [(Vertex, Node key payload)])--{--Note [reduceNodesIntoVertices implementations]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-reduceNodesIntoVertices is parameterized by the container type.-This is to accommodate key types that don't have an Ord instance-and hence preclude the use of Data.Map. An example of such type-would be Unique, there's no way to implement Ord Unique-deterministically.--For such types, there's a version with a Uniquable constraint.-This leaves us with two versions of every function that depends on-reduceNodesIntoVertices, one with Ord constraint and the other with-Uniquable constraint.-For example: graphFromEdgedVerticesOrd and graphFromEdgedVerticesUniq.--The Uniq version should be a tiny bit more efficient since it uses-Data.IntMap internally.--}-reduceNodesIntoVertices-  :: ([(key, Vertex)] -> m)-  -> (key -> m -> Maybe Vertex)-  -> ReduceFn key payload-reduceNodesIntoVertices fromList lookup nodes key_extractor =-  (bounds, (!) vertex_map, key_vertex, numbered_nodes)-  where-    max_v           = length nodes - 1-    bounds          = (0, max_v) :: (Vertex, Vertex)--    -- Keep the order intact to make the result depend on input order-    -- instead of key order-    numbered_nodes  = zip [0..] nodes-    vertex_map      = array bounds numbered_nodes--    key_map = fromList-      [ (key_extractor node, v) | (v, node) <- numbered_nodes ]-    key_vertex k = lookup k key_map---- See Note [reduceNodesIntoVertices implementations]-reduceNodesIntoVerticesOrd :: Ord key => ReduceFn key payload-reduceNodesIntoVerticesOrd = reduceNodesIntoVertices Map.fromList Map.lookup---- See Note [reduceNodesIntoVertices implementations]-reduceNodesIntoVerticesUniq :: Uniquable key => ReduceFn key payload-reduceNodesIntoVerticesUniq = reduceNodesIntoVertices listToUFM (flip lookupUFM)--{--************************************************************************-*                                                                      *-*      SCC-*                                                                      *-************************************************************************--}--type WorkItem key payload-  = (Node key payload,  -- Tip of the path-     [payload])         -- Rest of the path;-                        --  [a,b,c] means c depends on b, b depends on a---- | Find a reasonably short cycle a->b->c->a, in a strongly--- connected component.  The input nodes are presumed to be--- a SCC, so you can start anywhere.-findCycle :: forall payload key. Ord key-          => [Node key payload]     -- The nodes.  The dependencies can-                                    -- contain extra keys, which are ignored-          -> Maybe [payload]        -- A cycle, starting with node-                                    -- so each depends on the next-findCycle graph-  = go Set.empty (new_work root_deps []) []-  where-    env :: Map.Map key (Node key payload)-    env = Map.fromList [ (node_key node, node) | node <- graph ]--    -- Find the node with fewest dependencies among the SCC modules-    -- This is just a heuristic to find some plausible root module-    root :: Node key payload-    root = fst (minWith snd [ (node, count (`Map.member` env)-                                           (node_dependencies node))-                            | node <- graph ])-    DigraphNode root_payload root_key root_deps = root---    -- 'go' implements Dijkstra's algorithm, more or less-    go :: Set.Set key   -- Visited-       -> [WorkItem key payload]        -- Work list, items length n-       -> [WorkItem key payload]        -- Work list, items length n+1-       -> Maybe [payload]               -- Returned cycle-       -- Invariant: in a call (go visited ps qs),-       --            visited = union (map tail (ps ++ qs))--    go _       [] [] = Nothing  -- No cycles-    go visited [] qs = go visited qs []-    go visited (((DigraphNode payload key deps), path) : ps) qs-       | key == root_key           = Just (root_payload : reverse path)-       | key `Set.member` visited  = go visited ps qs-       | key `Map.notMember` env   = go visited ps qs-       | otherwise                 = go (Set.insert key visited)-                                        ps (new_qs ++ qs)-       where-         new_qs = new_work deps (payload : path)--    new_work :: [key] -> [payload] -> [WorkItem key payload]-    new_work deps path = [ (n, path) | Just n <- map (`Map.lookup` env) deps ]--{--************************************************************************-*                                                                      *-*      Strongly Connected Component wrappers for Graph-*                                                                      *-************************************************************************--Note: the components are returned topologically sorted: later components-depend on earlier ones, but not vice versa i.e. later components only have-edges going from them to earlier ones.--}--{--Note [Deterministic SCC]-~~~~~~~~~~~~~~~~~~~~~~~~-stronglyConnCompFromEdgedVerticesUniq,-stronglyConnCompFromEdgedVerticesUniqR,-stronglyConnCompFromEdgedVerticesOrd and-stronglyConnCompFromEdgedVerticesOrdR-provide a following guarantee:-Given a deterministically ordered list of nodes it returns a deterministically-ordered list of strongly connected components, where the list of vertices-in an SCC is also deterministically ordered.-Note that the order of edges doesn't need to be deterministic for this to work.-We use the order of nodes to normalize the order of edges.--}--stronglyConnCompG :: Graph node -> [SCC node]-stronglyConnCompG graph = decodeSccs graph forest-  where forest = {-# SCC "Digraph.scc" #-} scc (gr_int_graph graph)--decodeSccs :: Graph node -> Forest Vertex -> [SCC node]-decodeSccs Graph { gr_int_graph = graph, gr_vertex_to_node = vertex_fn } forest-  = map decode forest-  where-    decode (Node v []) | mentions_itself v = CyclicSCC [vertex_fn v]-                       | otherwise         = AcyclicSCC (vertex_fn v)-    decode other = CyclicSCC (dec other [])-      where dec (Node v ts) vs = vertex_fn v : foldr dec vs ts-    mentions_itself v = v `elem` (graph ! v)----- The following two versions are provided for backwards compatibility:--- See Note [Deterministic SCC]--- See Note [reduceNodesIntoVertices implementations]-stronglyConnCompFromEdgedVerticesOrd-        :: Ord key-        => [Node key payload]-        -> [SCC payload]-stronglyConnCompFromEdgedVerticesOrd-  = map (fmap node_payload) . stronglyConnCompFromEdgedVerticesOrdR---- The following two versions are provided for backwards compatibility:--- See Note [Deterministic SCC]--- See Note [reduceNodesIntoVertices implementations]-stronglyConnCompFromEdgedVerticesUniq-        :: Uniquable key-        => [Node key payload]-        -> [SCC payload]-stronglyConnCompFromEdgedVerticesUniq-  = map (fmap node_payload) . stronglyConnCompFromEdgedVerticesUniqR---- The "R" interface is used when you expect to apply SCC to--- (some of) the result of SCC, so you don't want to lose the dependency info--- See Note [Deterministic SCC]--- See Note [reduceNodesIntoVertices implementations]-stronglyConnCompFromEdgedVerticesOrdR-        :: Ord key-        => [Node key payload]-        -> [SCC (Node key payload)]-stronglyConnCompFromEdgedVerticesOrdR =-  stronglyConnCompG . graphFromEdgedVertices reduceNodesIntoVerticesOrd---- The "R" interface is used when you expect to apply SCC to--- (some of) the result of SCC, so you don't want to lose the dependency info--- See Note [Deterministic SCC]--- See Note [reduceNodesIntoVertices implementations]-stronglyConnCompFromEdgedVerticesUniqR-        :: Uniquable key-        => [Node key payload]-        -> [SCC (Node key payload)]-stronglyConnCompFromEdgedVerticesUniqR =-  stronglyConnCompG . graphFromEdgedVertices reduceNodesIntoVerticesUniq--{--************************************************************************-*                                                                      *-*      Misc wrappers for Graph-*                                                                      *-************************************************************************--}--topologicalSortG :: Graph node -> [node]-topologicalSortG graph = map (gr_vertex_to_node graph) result-  where result = {-# SCC "Digraph.topSort" #-} topSort (gr_int_graph graph)--reachableG :: Graph node -> node -> [node]-reachableG graph from = map (gr_vertex_to_node graph) result-  where from_vertex = expectJust "reachableG" (gr_node_to_vertex graph from)-        result = {-# SCC "Digraph.reachable" #-} reachable (gr_int_graph graph) [from_vertex]---- | Given a list of roots return all reachable nodes.-reachablesG :: Graph node -> [node] -> [node]-reachablesG graph froms = map (gr_vertex_to_node graph) result-  where result = {-# SCC "Digraph.reachable" #-}-                 reachable (gr_int_graph graph) vs-        vs = [ v | Just v <- map (gr_node_to_vertex graph) froms ]--hasVertexG :: Graph node -> node -> Bool-hasVertexG graph node = isJust $ gr_node_to_vertex graph node--verticesG :: Graph node -> [node]-verticesG graph = map (gr_vertex_to_node graph) $ vertices (gr_int_graph graph)--edgesG :: Graph node -> [Edge node]-edgesG graph = map (\(v1, v2) -> Edge (v2n v1) (v2n v2)) $ edges (gr_int_graph graph)-  where v2n = gr_vertex_to_node graph--transposeG :: Graph node -> Graph node-transposeG graph = Graph (G.transposeG (gr_int_graph graph))-                         (gr_vertex_to_node graph)-                         (gr_node_to_vertex graph)--emptyG :: Graph node -> Bool-emptyG g = graphEmpty (gr_int_graph g)--{--************************************************************************-*                                                                      *-*      Showing Graphs-*                                                                      *-************************************************************************--}--instance Outputable node => Outputable (Graph node) where-    ppr graph = vcat [-                  hang (text "Vertices:") 2 (vcat (map ppr $ verticesG graph)),-                  hang (text "Edges:") 2 (vcat (map ppr $ edgesG graph))-                ]--instance Outputable node => Outputable (Edge node) where-    ppr (Edge from to) = ppr from <+> text "->" <+> ppr to--graphEmpty :: G.Graph -> Bool-graphEmpty g = lo > hi-  where (lo, hi) = bounds g--{--************************************************************************-*                                                                      *-*      IntGraphs-*                                                                      *-************************************************************************--}--type IntGraph = G.Graph--{----------------------------------------------------------------- Depth first search numbering---------------------------------------------------------------}---- Data.Tree has flatten for Tree, but nothing for Forest-preorderF           :: Forest a -> [a]-preorderF ts         = concatMap flatten ts--{----------------------------------------------------------------- Finding reachable vertices---------------------------------------------------------------}---- This generalizes reachable which was found in Data.Graph-reachable    :: IntGraph -> [Vertex] -> [Vertex]-reachable g vs = preorderF (dfs g vs)--{--************************************************************************-*                                                                      *-*                         Classify Edge Types-*                                                                      *-************************************************************************--}---- Remark: While we could generalize this algorithm this comes at a runtime--- cost and with no advantages. If you find yourself using this with graphs--- not easily represented using Int nodes please consider rewriting this--- using the more general Graph type.---- | Edge direction based on DFS Classification-data EdgeType-  = Forward-  | Cross-  | Backward -- ^ Loop back towards the root node.-             -- Eg backjumps in loops-  | SelfLoop -- ^ v -> v-   deriving (Eq,Ord)--instance Outputable EdgeType where-  ppr Forward = text "Forward"-  ppr Cross = text "Cross"-  ppr Backward = text "Backward"-  ppr SelfLoop = text "SelfLoop"--newtype Time = Time Int deriving (Eq,Ord,Num,Outputable)----Allow for specialization-{-# INLINEABLE classifyEdges #-}---- | Given a start vertex, a way to get successors from a node--- and a list of (directed) edges classify the types of edges.-classifyEdges :: forall key. Uniquable key => key -> (key -> [key])-              -> [(key,key)] -> [((key, key), EdgeType)]-classifyEdges root getSucc edges =-    --let uqe (from,to) = (getUnique from, getUnique to)-    --in pprTrace "Edges:" (ppr $ map uqe edges) $-    zip edges $ map classify edges-  where-    (_time, starts, ends) = addTimes (0,emptyUFM,emptyUFM) root-    classify :: (key,key) -> EdgeType-    classify (from,to)-      | startFrom < startTo-      , endFrom   > endTo-      = Forward-      | startFrom > startTo-      , endFrom   < endTo-      = Backward-      | startFrom > startTo-      , endFrom   > endTo-      = Cross-      | getUnique from == getUnique to-      = SelfLoop-      | otherwise-      = pprPanic "Failed to classify edge of Graph"-                 (ppr (getUnique from, getUnique to))--      where-        getTime event node-          | Just time <- lookupUFM event node-          = time-          | otherwise-          = pprPanic "Failed to classify edge of CFG - not not timed"-            (text "edges" <> ppr (getUnique from, getUnique to)-                          <+> ppr starts <+> ppr ends )-        startFrom = getTime starts from-        startTo   = getTime starts to-        endFrom   = getTime ends   from-        endTo     = getTime ends   to--    addTimes :: (Time, UniqFM Time, UniqFM Time) -> key-             -> (Time, UniqFM Time, UniqFM Time)-    addTimes (time,starts,ends) n-      --Dont reenter nodes-      | elemUFM n starts-      = (time,starts,ends)-      | otherwise =-        let-          starts' = addToUFM starts n time-          time' = time + 1-          succs = getSucc n :: [key]-          (time'',starts'',ends') = foldl' addTimes (time',starts',ends) succs-          ends'' = addToUFM ends' n time''-        in-        (time'' + 1, starts'', ends'')
− compiler/utils/Encoding.hs 
@@ -1,450 +0,0 @@-{-# LANGUAGE BangPatterns, MagicHash, UnboxedTuples #-}-{-# OPTIONS_GHC -O2 #-}--- We always optimise this, otherwise performance of a non-optimised--- compiler is severely affected---- ----------------------------------------------------------------------------------- (c) The University of Glasgow, 1997-2006------ Character encodings------ -------------------------------------------------------------------------------module Encoding (-        -- * UTF-8-        utf8DecodeChar#,-        utf8PrevChar,-        utf8CharStart,-        utf8DecodeChar,-        utf8DecodeByteString,-        utf8DecodeStringLazy,-        utf8EncodeChar,-        utf8EncodeString,-        utf8EncodedLength,-        countUTF8Chars,--        -- * Z-encoding-        zEncodeString,-        zDecodeString,--        -- * Base62-encoding-        toBase62,-        toBase62Padded-  ) where--import GhcPrelude--import Foreign-import Foreign.ForeignPtr.Unsafe-import Data.Char-import qualified Data.Char as Char-import Numeric-import GHC.IO--import Data.ByteString (ByteString)-import qualified Data.ByteString.Internal as BS--import GHC.Exts---- -------------------------------------------------------------------------------- UTF-8---- We can't write the decoder as efficiently as we'd like without--- resorting to unboxed extensions, unfortunately.  I tried to write--- an IO version of this function, but GHC can't eliminate boxed--- results from an IO-returning function.------ We assume we can ignore overflow when parsing a multibyte character here.--- To make this safe, we add extra sentinel bytes to unparsed UTF-8 sequences--- before decoding them (see StringBuffer.hs).--{-# INLINE utf8DecodeChar# #-}-utf8DecodeChar# :: Addr# -> (# Char#, Int# #)-utf8DecodeChar# a# =-  let !ch0 = word2Int# (indexWord8OffAddr# a# 0#) in-  case () of-    _ | isTrue# (ch0 <=# 0x7F#) -> (# chr# ch0, 1# #)--      | isTrue# ((ch0 >=# 0xC0#) `andI#` (ch0 <=# 0xDF#)) ->-        let !ch1 = word2Int# (indexWord8OffAddr# a# 1#) in-        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else-        (# chr# (((ch0 -# 0xC0#) `uncheckedIShiftL#` 6#) +#-                  (ch1 -# 0x80#)),-           2# #)--      | isTrue# ((ch0 >=# 0xE0#) `andI#` (ch0 <=# 0xEF#)) ->-        let !ch1 = word2Int# (indexWord8OffAddr# a# 1#) in-        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else-        let !ch2 = word2Int# (indexWord8OffAddr# a# 2#) in-        if isTrue# ((ch2 <# 0x80#) `orI#` (ch2 >=# 0xC0#)) then fail 2# else-        (# chr# (((ch0 -# 0xE0#) `uncheckedIShiftL#` 12#) +#-                 ((ch1 -# 0x80#) `uncheckedIShiftL#` 6#)  +#-                  (ch2 -# 0x80#)),-           3# #)--     | isTrue# ((ch0 >=# 0xF0#) `andI#` (ch0 <=# 0xF8#)) ->-        let !ch1 = word2Int# (indexWord8OffAddr# a# 1#) in-        if isTrue# ((ch1 <# 0x80#) `orI#` (ch1 >=# 0xC0#)) then fail 1# else-        let !ch2 = word2Int# (indexWord8OffAddr# a# 2#) in-        if isTrue# ((ch2 <# 0x80#) `orI#` (ch2 >=# 0xC0#)) then fail 2# else-        let !ch3 = word2Int# (indexWord8OffAddr# a# 3#) in-        if isTrue# ((ch3 <# 0x80#) `orI#` (ch3 >=# 0xC0#)) then fail 3# else-        (# chr# (((ch0 -# 0xF0#) `uncheckedIShiftL#` 18#) +#-                 ((ch1 -# 0x80#) `uncheckedIShiftL#` 12#) +#-                 ((ch2 -# 0x80#) `uncheckedIShiftL#` 6#)  +#-                  (ch3 -# 0x80#)),-           4# #)--      | otherwise -> fail 1#-  where-        -- all invalid sequences end up here:-        fail :: Int# -> (# Char#, Int# #)-        fail nBytes# = (# '\0'#, nBytes# #)-        -- '\xFFFD' would be the usual replacement character, but-        -- that's a valid symbol in Haskell, so will result in a-        -- confusing parse error later on.  Instead we use '\0' which-        -- will signal a lexer error immediately.--utf8DecodeChar :: Ptr Word8 -> (Char, Int)-utf8DecodeChar (Ptr a#) =-  case utf8DecodeChar# a# of (# c#, nBytes# #) -> ( C# c#, I# nBytes# )---- UTF-8 is cleverly designed so that we can always figure out where--- the start of the current character is, given any position in a--- stream.  This function finds the start of the previous character,--- assuming there *is* a previous character.-utf8PrevChar :: Ptr Word8 -> IO (Ptr Word8)-utf8PrevChar p = utf8CharStart (p `plusPtr` (-1))--utf8CharStart :: Ptr Word8 -> IO (Ptr Word8)-utf8CharStart p = go p- where go p = do w <- peek p-                 if w >= 0x80 && w < 0xC0-                        then go (p `plusPtr` (-1))-                        else return p--utf8DecodeByteString :: ByteString -> [Char]-utf8DecodeByteString (BS.PS ptr offset len)-  = utf8DecodeStringLazy ptr offset len--utf8DecodeStringLazy :: ForeignPtr Word8 -> Int -> Int -> [Char]-utf8DecodeStringLazy fptr offset len-  = unsafeDupablePerformIO $ unpack start-  where-    !start = unsafeForeignPtrToPtr fptr `plusPtr` offset-    !end = start `plusPtr` len--    unpack p-        | p >= end  = touchForeignPtr fptr >> return []-        | otherwise =-            case utf8DecodeChar# (unPtr p) of-                (# c#, nBytes# #) -> do-                  rest <- unsafeDupableInterleaveIO $ unpack (p `plusPtr#` nBytes#)-                  return (C# c# : rest)--countUTF8Chars :: Ptr Word8 -> Int -> IO Int-countUTF8Chars ptr len = go ptr 0-  where-        !end = ptr `plusPtr` len--        go p !n-           | p >= end = return n-           | otherwise  = do-                case utf8DecodeChar# (unPtr p) of-                  (# _, nBytes# #) -> go (p `plusPtr#` nBytes#) (n+1)--unPtr :: Ptr a -> Addr#-unPtr (Ptr a) = a--plusPtr# :: Ptr a -> Int# -> Ptr a-plusPtr# ptr nBytes# = ptr `plusPtr` (I# nBytes#)--utf8EncodeChar :: Char -> Ptr Word8 -> IO (Ptr Word8)-utf8EncodeChar c ptr =-  let x = ord c in-  case () of-    _ | x > 0 && x <= 0x007f -> do-          poke ptr (fromIntegral x)-          return (ptr `plusPtr` 1)-        -- NB. '\0' is encoded as '\xC0\x80', not '\0'.  This is so that we-        -- can have 0-terminated UTF-8 strings (see GHC.Base.unpackCStringUtf8).-      | x <= 0x07ff -> do-          poke ptr (fromIntegral (0xC0 .|. ((x `shiftR` 6) .&. 0x1F)))-          pokeElemOff ptr 1 (fromIntegral (0x80 .|. (x .&. 0x3F)))-          return (ptr `plusPtr` 2)-      | x <= 0xffff -> do-          poke ptr (fromIntegral (0xE0 .|. (x `shiftR` 12) .&. 0x0F))-          pokeElemOff ptr 1 (fromIntegral (0x80 .|. (x `shiftR` 6) .&. 0x3F))-          pokeElemOff ptr 2 (fromIntegral (0x80 .|. (x .&. 0x3F)))-          return (ptr `plusPtr` 3)-      | otherwise -> do-          poke ptr (fromIntegral (0xF0 .|. (x `shiftR` 18)))-          pokeElemOff ptr 1 (fromIntegral (0x80 .|. ((x `shiftR` 12) .&. 0x3F)))-          pokeElemOff ptr 2 (fromIntegral (0x80 .|. ((x `shiftR` 6) .&. 0x3F)))-          pokeElemOff ptr 3 (fromIntegral (0x80 .|. (x .&. 0x3F)))-          return (ptr `plusPtr` 4)--utf8EncodeString :: Ptr Word8 -> String -> IO ()-utf8EncodeString ptr str = go ptr str-  where go !_   []     = return ()-        go ptr (c:cs) = do-          ptr' <- utf8EncodeChar c ptr-          go ptr' cs--utf8EncodedLength :: String -> Int-utf8EncodedLength str = go 0 str-  where go !n [] = n-        go n (c:cs)-          | ord c > 0 && ord c <= 0x007f = go (n+1) cs-          | ord c <= 0x07ff = go (n+2) cs-          | ord c <= 0xffff = go (n+3) cs-          | otherwise       = go (n+4) cs---- -------------------------------------------------------------------------------- The Z-encoding--{--This is the main name-encoding and decoding function.  It encodes any-string into a string that is acceptable as a C name.  This is done-right before we emit a symbol name into the compiled C or asm code.-Z-encoding of strings is cached in the FastString interface, so we-never encode the same string more than once.--The basic encoding scheme is this.--* Tuples (,,,) are coded as Z3T--* Alphabetic characters (upper and lower) and digits-        all translate to themselves;-        except 'Z', which translates to 'ZZ'-        and    'z', which translates to 'zz'-  We need both so that we can preserve the variable/tycon distinction--* Most other printable characters translate to 'zx' or 'Zx' for some-        alphabetic character x--* The others translate as 'znnnU' where 'nnn' is the decimal number-        of the character--        Before          After-        ---------------------------        Trak            Trak-        foo_wib         foozuwib-        >               zg-        >1              zg1-        foo#            foozh-        foo##           foozhzh-        foo##1          foozhzh1-        fooZ            fooZZ-        :+              ZCzp-        ()              Z0T     0-tuple-        (,,,,)          Z5T     5-tuple-        (# #)           Z1H     unboxed 1-tuple (note the space)-        (#,,,,#)        Z5H     unboxed 5-tuple-                (NB: There is no Z1T nor Z0H.)--}--type UserString = String        -- As the user typed it-type EncodedString = String     -- Encoded form---zEncodeString :: UserString -> EncodedString-zEncodeString cs = case maybe_tuple cs of-                Just n  -> n            -- Tuples go to Z2T etc-                Nothing -> go cs-          where-                go []     = []-                go (c:cs) = encode_digit_ch c ++ go' cs-                go' []     = []-                go' (c:cs) = encode_ch c ++ go' cs--unencodedChar :: Char -> Bool   -- True for chars that don't need encoding-unencodedChar 'Z' = False-unencodedChar 'z' = False-unencodedChar c   =  c >= 'a' && c <= 'z'-                  || c >= 'A' && c <= 'Z'-                  || c >= '0' && c <= '9'---- If a digit is at the start of a symbol then we need to encode it.--- Otherwise package names like 9pH-0.1 give linker errors.-encode_digit_ch :: Char -> EncodedString-encode_digit_ch c | c >= '0' && c <= '9' = encode_as_unicode_char c-encode_digit_ch c | otherwise            = encode_ch c--encode_ch :: Char -> EncodedString-encode_ch c | unencodedChar c = [c]     -- Common case first---- Constructors-encode_ch '('  = "ZL"   -- Needed for things like (,), and (->)-encode_ch ')'  = "ZR"   -- For symmetry with (-encode_ch '['  = "ZM"-encode_ch ']'  = "ZN"-encode_ch ':'  = "ZC"-encode_ch 'Z'  = "ZZ"---- Variables-encode_ch 'z'  = "zz"-encode_ch '&'  = "za"-encode_ch '|'  = "zb"-encode_ch '^'  = "zc"-encode_ch '$'  = "zd"-encode_ch '='  = "ze"-encode_ch '>'  = "zg"-encode_ch '#'  = "zh"-encode_ch '.'  = "zi"-encode_ch '<'  = "zl"-encode_ch '-'  = "zm"-encode_ch '!'  = "zn"-encode_ch '+'  = "zp"-encode_ch '\'' = "zq"-encode_ch '\\' = "zr"-encode_ch '/'  = "zs"-encode_ch '*'  = "zt"-encode_ch '_'  = "zu"-encode_ch '%'  = "zv"-encode_ch c    = encode_as_unicode_char c--encode_as_unicode_char :: Char -> EncodedString-encode_as_unicode_char c = 'z' : if isDigit (head hex_str) then hex_str-                                                           else '0':hex_str-  where hex_str = showHex (ord c) "U"-  -- ToDo: we could improve the encoding here in various ways.-  -- eg. strings of unicode characters come out as 'z1234Uz5678U', we-  -- could remove the 'U' in the middle (the 'z' works as a separator).--zDecodeString :: EncodedString -> UserString-zDecodeString [] = []-zDecodeString ('Z' : d : rest)-  | isDigit d = decode_tuple   d rest-  | otherwise = decode_upper   d : zDecodeString rest-zDecodeString ('z' : d : rest)-  | isDigit d = decode_num_esc d rest-  | otherwise = decode_lower   d : zDecodeString rest-zDecodeString (c   : rest) = c : zDecodeString rest--decode_upper, decode_lower :: Char -> Char--decode_upper 'L' = '('-decode_upper 'R' = ')'-decode_upper 'M' = '['-decode_upper 'N' = ']'-decode_upper 'C' = ':'-decode_upper 'Z' = 'Z'-decode_upper ch  = {-pprTrace "decode_upper" (char ch)-} ch--decode_lower 'z' = 'z'-decode_lower 'a' = '&'-decode_lower 'b' = '|'-decode_lower 'c' = '^'-decode_lower 'd' = '$'-decode_lower 'e' = '='-decode_lower 'g' = '>'-decode_lower 'h' = '#'-decode_lower 'i' = '.'-decode_lower 'l' = '<'-decode_lower 'm' = '-'-decode_lower 'n' = '!'-decode_lower 'p' = '+'-decode_lower 'q' = '\''-decode_lower 'r' = '\\'-decode_lower 's' = '/'-decode_lower 't' = '*'-decode_lower 'u' = '_'-decode_lower 'v' = '%'-decode_lower ch  = {-pprTrace "decode_lower" (char ch)-} ch---- Characters not having a specific code are coded as z224U (in hex)-decode_num_esc :: Char -> EncodedString -> UserString-decode_num_esc d rest-  = go (digitToInt d) rest-  where-    go n (c : rest) | isHexDigit c = go (16*n + digitToInt c) rest-    go n ('U' : rest)           = chr n : zDecodeString rest-    go n other = error ("decode_num_esc: " ++ show n ++  ' ':other)--decode_tuple :: Char -> EncodedString -> UserString-decode_tuple d rest-  = go (digitToInt d) rest-  where-        -- NB. recurse back to zDecodeString after decoding the tuple, because-        -- the tuple might be embedded in a longer name.-    go n (c : rest) | isDigit c = go (10*n + digitToInt c) rest-    go 0 ('T':rest)     = "()" ++ zDecodeString rest-    go n ('T':rest)     = '(' : replicate (n-1) ',' ++ ")" ++ zDecodeString rest-    go 1 ('H':rest)     = "(# #)" ++ zDecodeString rest-    go n ('H':rest)     = '(' : '#' : replicate (n-1) ',' ++ "#)" ++ zDecodeString rest-    go n other = error ("decode_tuple: " ++ show n ++ ' ':other)--{--Tuples are encoded as-        Z3T or Z3H-for 3-tuples or unboxed 3-tuples respectively.  No other encoding starts-        Z<digit>--* "(# #)" is the tycon for an unboxed 1-tuple (not 0-tuple)-  There are no unboxed 0-tuples.--* "()" is the tycon for a boxed 0-tuple.-  There are no boxed 1-tuples.--}--maybe_tuple :: UserString -> Maybe EncodedString--maybe_tuple "(# #)" = Just("Z1H")-maybe_tuple ('(' : '#' : cs) = case count_commas (0::Int) cs of-                                 (n, '#' : ')' : _) -> Just ('Z' : shows (n+1) "H")-                                 _                  -> Nothing-maybe_tuple "()" = Just("Z0T")-maybe_tuple ('(' : cs)       = case count_commas (0::Int) cs of-                                 (n, ')' : _) -> Just ('Z' : shows (n+1) "T")-                                 _            -> Nothing-maybe_tuple _                = Nothing--count_commas :: Int -> String -> (Int, String)-count_commas n (',' : cs) = count_commas (n+1) cs-count_commas n cs         = (n,cs)---{--************************************************************************-*                                                                      *-                        Base 62-*                                                                      *-************************************************************************--Note [Base 62 encoding 128-bit integers]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Instead of base-62 encoding a single 128-bit integer-(ceil(21.49) characters), we'll base-62 a pair of 64-bit integers-(2 * ceil(10.75) characters).  Luckily for us, it's the same number of-characters!--}------------------------------------------------------------------------------- Base 62---- The base-62 code is based off of 'locators'--- ((c) Operational Dynamics Consulting, BSD3 licensed)---- | Size of a 64-bit word when written as a base-62 string-word64Base62Len :: Int-word64Base62Len = 11---- | Converts a 64-bit word into a base-62 string-toBase62Padded :: Word64 -> String-toBase62Padded w = pad ++ str-  where-    pad = replicate len '0'-    len = word64Base62Len - length str -- 11 == ceil(64 / lg 62)-    str = toBase62 w--toBase62 :: Word64 -> String-toBase62 w = showIntAtBase 62 represent w ""-  where-    represent :: Int -> Char-    represent x-        | x < 10 = Char.chr (48 + x)-        | x < 36 = Char.chr (65 + x - 10)-        | x < 62 = Char.chr (97 + x - 36)-        | otherwise = error "represent (base 62): impossible!"
− compiler/utils/EnumSet.hs 
@@ -1,35 +0,0 @@--- | A tiny wrapper around 'IntSet.IntSet' for representing sets of 'Enum'--- things.-module EnumSet-    ( EnumSet-    , member-    , insert-    , delete-    , toList-    , fromList-    , empty-    ) where--import GhcPrelude--import qualified Data.IntSet as IntSet--newtype EnumSet a = EnumSet IntSet.IntSet--member :: Enum a => a -> EnumSet a -> Bool-member x (EnumSet s) = IntSet.member (fromEnum x) s--insert :: Enum a => a -> EnumSet a -> EnumSet a-insert x (EnumSet s) = EnumSet $ IntSet.insert (fromEnum x) s--delete :: Enum a => a -> EnumSet a -> EnumSet a-delete x (EnumSet s) = EnumSet $ IntSet.delete (fromEnum x) s--toList :: Enum a => EnumSet a -> [a]-toList (EnumSet s) = map toEnum $ IntSet.toList s--fromList :: Enum a => [a] -> EnumSet a-fromList = EnumSet . IntSet.fromList . map fromEnum--empty :: EnumSet a-empty = EnumSet IntSet.empty
− compiler/utils/Exception.hs 
@@ -1,83 +0,0 @@-{-# OPTIONS_GHC -fno-warn-deprecations #-}-module Exception-    (-    module Control.Exception,-    module Exception-    )-    where--import GhcPrelude--import Control.Exception-import Control.Monad.IO.Class--catchIO :: IO a -> (IOException -> IO a) -> IO a-catchIO = Control.Exception.catch--handleIO :: (IOException -> IO a) -> IO a -> IO a-handleIO = flip catchIO--tryIO :: IO a -> IO (Either IOException a)-tryIO = try---- | A monad that can catch exceptions.  A minimal definition--- requires a definition of 'gcatch'.------ Implementations on top of 'IO' should implement 'gmask' to--- eventually call the primitive 'Control.Exception.mask'.--- These are used for--- implementations that support asynchronous exceptions.  The default--- implementations of 'gbracket' and 'gfinally' use 'gmask'--- thus rarely require overriding.----class MonadIO m => ExceptionMonad m where--  -- | Generalised version of 'Control.Exception.catch', allowing an arbitrary-  -- exception handling monad instead of just 'IO'.-  gcatch :: Exception e => m a -> (e -> m a) -> m a--  -- | Generalised version of 'Control.Exception.mask_', allowing an arbitrary-  -- exception handling monad instead of just 'IO'.-  gmask :: ((m a -> m a) -> m b) -> m b--  -- | Generalised version of 'Control.Exception.bracket', allowing an arbitrary-  -- exception handling monad instead of just 'IO'.-  gbracket :: m a -> (a -> m b) -> (a -> m c) -> m c--  -- | Generalised version of 'Control.Exception.finally', allowing an arbitrary-  -- exception handling monad instead of just 'IO'.-  gfinally :: m a -> m b -> m a--  gbracket before after thing =-    gmask $ \restore -> do-      a <- before-      r <- restore (thing a) `gonException` after a-      _ <- after a-      return r--  a `gfinally` sequel =-    gmask $ \restore -> do-      r <- restore a `gonException` sequel-      _ <- sequel-      return r--instance ExceptionMonad IO where-  gcatch    = Control.Exception.catch-  gmask f   = mask (\x -> f x)--gtry :: (ExceptionMonad m, Exception e) => m a -> m (Either e a)-gtry act = gcatch (act >>= \a -> return (Right a))-                  (\e -> return (Left e))---- | Generalised version of 'Control.Exception.handle', allowing an arbitrary--- exception handling monad instead of just 'IO'.-ghandle :: (ExceptionMonad m, Exception e) => (e -> m a) -> m a -> m a-ghandle = flip gcatch---- | Always executes the first argument.  If this throws an exception the--- second argument is executed and the exception is raised again.-gonException :: (ExceptionMonad m) => m a -> m b -> m a-gonException ioA cleanup = ioA `gcatch` \e ->-                             do _ <- cleanup-                                liftIO $ throwIO (e :: SomeException)-
− compiler/utils/FV.hs 
@@ -1,200 +0,0 @@-{--(c) Bartosz Nitka, Facebook 2015--Utilities for efficiently and deterministically computing free variables.---}--{-# LANGUAGE BangPatterns #-}--module FV (-        -- * Deterministic free vars computations-        FV, InterestingVarFun,--        -- * Running the computations-        fvVarList, fvVarSet, fvDVarSet,--        -- ** Manipulating those computations-        unitFV,-        emptyFV,-        mkFVs,-        unionFV,-        unionsFV,-        delFV,-        delFVs,-        filterFV,-        mapUnionFV,-    ) where--import GhcPrelude--import GHC.Types.Var-import GHC.Types.Var.Set---- | Predicate on possible free variables: returns @True@ iff the variable is--- interesting-type InterestingVarFun = Var -> Bool---- Note [Deterministic FV]--- ~~~~~~~~~~~~~~~~~~~~~~~--- When computing free variables, the order in which you get them affects--- the results of floating and specialization. If you use UniqFM to collect--- them and then turn that into a list, you get them in nondeterministic--- order as described in Note [Deterministic UniqFM] in GHC.Types.Unique.DFM.---- A naive algorithm for free variables relies on merging sets of variables.--- 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-        -> 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 GHC.Types.Unique.DFM.---- 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` That means the functions--- returning FV need to be exported.------ The conventions are:------ a) non-deterministic functions:---   * a function that returns VarSet---       e.g. `tyVarsOfType`--- b) deterministic functions:---   * a worker that returns FV---       e.g. `tyFVsOfType`---   * a function that returns [Var]---       e.g. `tyVarsOfTypeList`---   * a function that returns DVarSet---       e.g. `tyVarsOfTypeDSet`------ Where tyVarsOfType, tyVarsOfTypeList, tyVarsOfTypeDSet are implemented--- in terms of the worker evaluated with fvVarSet, fvVarList, fvDVarSet--- respectively.---- | Run a free variable computation, returning a list of distinct free--- variables in deterministic order and a non-deterministic set containing--- those variables.-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 . 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 . 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 . fvVarAcc---- Note [FV eta expansion]--- ~~~~~~~~~~~~~~~~~~~~~~~--- Let's consider an eta-reduced implementation of freeVarsOf using FV:------ freeVarsOf (App a b) = freeVarsOf a `unionFV` freeVarsOf b------ If GHC doesn't eta-expand it, after inlining unionFV we end up with------ freeVarsOf = \x ->---   case x of---     App a b -> \fv_cand in_scope acc ->---       freeVarsOf a fv_cand in_scope $! freeVarsOf b fv_cand in_scope $! acc------ which has to create a thunk, resulting in more allocations.------ On the other hand if it is eta-expanded:------ freeVarsOf (App a b) fv_cand in_scope acc =---   (freeVarsOf a `unionFV` freeVarsOf b) fv_cand in_scope acc------ after inlining unionFV we have:------ freeVarsOf = \x fv_cand in_scope acc ->---   case x of---     App a b ->---       freeVarsOf a fv_cand in_scope $! freeVarsOf b fv_cand in_scope $! acc------ which saves allocations.------ GHC when presented with knowledge about all the call sites, correctly--- eta-expands in this case. Unfortunately due to the fact that freeVarsOf gets--- exported to be composed with other functions, GHC doesn't have that--- information and has to be more conservative here.------ Hence functions that get exported and return FV need to be manually--- eta-expanded. See also #11146.---- | Add a variable - when free, to the returned free variables.--- Ignores duplicates and respects the filtering function.-unitFV :: Id -> FV-unitFV var fv_cand in_scope acc@(have, haveSet)-  | var `elemVarSet` in_scope = acc-  | var `elemVarSet` haveSet = acc-  | fv_cand var = (var:have, extendVarSet haveSet var)-  | otherwise = acc-{-# INLINE unitFV #-}---- | Return no free variables.-emptyFV :: FV-emptyFV _ _ acc = acc-{-# INLINE emptyFV #-}---- | Union two free variable computations.-unionFV :: FV -> FV -> FV-unionFV fv1 fv2 fv_cand in_scope acc =-  fv1 fv_cand in_scope $! fv2 fv_cand in_scope $! acc-{-# INLINE unionFV #-}---- | Mark the variable as not free by putting it in scope.-delFV :: Var -> FV -> FV-delFV var fv fv_cand !in_scope acc =-  fv fv_cand (extendVarSet in_scope var) acc-{-# INLINE delFV #-}---- | Mark many free variables as not free.-delFVs :: VarSet -> FV -> FV-delFVs vars fv fv_cand !in_scope acc =-  fv fv_cand (in_scope `unionVarSet` vars) acc-{-# INLINE delFVs #-}---- | Filter a free variable computation.-filterFV :: InterestingVarFun -> FV -> FV-filterFV fv_cand2 fv fv_cand1 in_scope acc =-  fv (\v -> fv_cand1 v && fv_cand2 v) in_scope acc-{-# INLINE filterFV #-}---- | Map a free variable computation over a list and union the results.-mapUnionFV :: (a -> FV) -> [a] -> FV-mapUnionFV _f [] _fv_cand _in_scope acc = acc-mapUnionFV f (a:as) fv_cand in_scope acc =-  mapUnionFV f as fv_cand in_scope $! f a fv_cand in_scope $! acc-{-# INLINABLE mapUnionFV #-}---- | Union many free variable computations.-unionsFV :: [FV] -> FV-unionsFV fvs fv_cand in_scope acc = mapUnionFV id fvs fv_cand in_scope acc-{-# INLINE unionsFV #-}---- | Add multiple variables - when free, to the returned free variables.--- Ignores duplicates and respects the filtering function.-mkFVs :: [Var] -> FV-mkFVs vars fv_cand in_scope acc =-  mapUnionFV unitFV vars fv_cand in_scope acc-{-# INLINE mkFVs #-}
− compiler/utils/FastFunctions.hs 
@@ -1,21 +0,0 @@-{--(c) The University of Glasgow, 2000-2006--}--{-# LANGUAGE CPP, MagicHash, UnboxedTuples #-}--module FastFunctions (-    inlinePerformIO,-  ) where--#include "HsVersions.h"--import GhcPrelude ()--import GHC.Exts-import GHC.IO   (IO(..))---- Just like unsafeDupablePerformIO, but we inline it.-{-# INLINE inlinePerformIO #-}-inlinePerformIO :: IO a -> a-inlinePerformIO (IO m) = case m realWorld# of (# _, r #)   -> r
− compiler/utils/FastMutInt.hs 
@@ -1,61 +0,0 @@-{-# LANGUAGE BangPatterns, MagicHash, UnboxedTuples #-}-{-# OPTIONS_GHC -O2 #-}--- We always optimise this, otherwise performance of a non-optimised--- compiler is severely affected------ (c) The University of Glasgow 2002-2006------ Unboxed mutable Ints--module FastMutInt(-        FastMutInt, newFastMutInt,-        readFastMutInt, writeFastMutInt,--        FastMutPtr, newFastMutPtr,-        readFastMutPtr, writeFastMutPtr-  ) where--import GhcPrelude--import Data.Bits-import GHC.Base-import GHC.Ptr--newFastMutInt :: IO FastMutInt-readFastMutInt :: FastMutInt -> IO Int-writeFastMutInt :: FastMutInt -> Int -> IO ()--newFastMutPtr :: IO FastMutPtr-readFastMutPtr :: FastMutPtr -> IO (Ptr a)-writeFastMutPtr :: FastMutPtr -> Ptr a -> IO ()--data FastMutInt = FastMutInt (MutableByteArray# RealWorld)--newFastMutInt = IO $ \s ->-  case newByteArray# size s of { (# s, arr #) ->-  (# s, FastMutInt arr #) }-  where !(I# size) = finiteBitSize (0 :: Int)--readFastMutInt (FastMutInt arr) = IO $ \s ->-  case readIntArray# arr 0# s of { (# s, i #) ->-  (# s, I# i #) }--writeFastMutInt (FastMutInt arr) (I# i) = IO $ \s ->-  case writeIntArray# arr 0# i s of { s ->-  (# s, () #) }--data FastMutPtr = FastMutPtr (MutableByteArray# RealWorld)--newFastMutPtr = IO $ \s ->-  case newByteArray# size s of { (# s, arr #) ->-  (# s, FastMutPtr arr #) }-  -- GHC assumes 'sizeof (Int) == sizeof (Ptr a)'-  where !(I# size) = finiteBitSize (0 :: Int)--readFastMutPtr (FastMutPtr arr) = IO $ \s ->-  case readAddrArray# arr 0# s of { (# s, i #) ->-  (# s, Ptr i #) }--writeFastMutPtr (FastMutPtr arr) (Ptr i) = IO $ \s ->-  case writeAddrArray# arr 0# i s of { s ->-  (# s, () #) }
− compiler/utils/FastString.hs 
@@ -1,693 +0,0 @@--- (c) The University of Glasgow, 1997-2006--{-# LANGUAGE BangPatterns, CPP, MagicHash, UnboxedTuples,-    GeneralizedNewtypeDeriving #-}-{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}--- We always optimise this, otherwise performance of a non-optimised--- compiler is severely affected---- |--- There are two principal string types used internally by GHC:------ ['FastString']------   * A compact, hash-consed, representation of character strings.---   * Comparison is O(1), and you can get a 'Unique.Unique' from them.---   * Generated by 'fsLit'.---   * Turn into 'Outputable.SDoc' with 'Outputable.ftext'.------ ['PtrString']------   * Pointer and size of a Latin-1 encoded string.---   * Practically no operations.---   * Outputting them is fast.---   * Generated by 'sLit'.---   * Turn into 'Outputable.SDoc' with 'Outputable.ptext'---   * Requires manual memory management.---     Improper use may lead to memory leaks or dangling pointers.---   * It assumes Latin-1 as the encoding, therefore it cannot represent---     arbitrary Unicode strings.------ Use 'PtrString' unless you want the facilities of 'FastString'.-module FastString-       (-        -- * ByteString-        bytesFS,            -- :: FastString -> ByteString-        fastStringToByteString, -- = bytesFS (kept for haddock)-        mkFastStringByteString,-        fastZStringToByteString,-        unsafeMkByteString,--        -- * FastZString-        FastZString,-        hPutFZS,-        zString,-        lengthFZS,--        -- * FastStrings-        FastString(..),     -- not abstract, for now.--        -- ** Construction-        fsLit,-        mkFastString,-        mkFastStringBytes,-        mkFastStringByteList,-        mkFastStringForeignPtr,-        mkFastString#,--        -- ** Deconstruction-        unpackFS,           -- :: FastString -> String--        -- ** Encoding-        zEncodeFS,--        -- ** Operations-        uniqueOfFS,-        lengthFS,-        nullFS,-        appendFS,-        headFS,-        tailFS,-        concatFS,-        consFS,-        nilFS,-        isUnderscoreFS,--        -- ** Outputting-        hPutFS,--        -- ** Internal-        getFastStringTable,-        getFastStringZEncCounter,--        -- * PtrStrings-        PtrString (..),--        -- ** Construction-        sLit,-        mkPtrString#,-        mkPtrString,--        -- ** Deconstruction-        unpackPtrString,--        -- ** Operations-        lengthPS-       ) where--#include "HsVersions.h"--import GhcPrelude as Prelude--import Encoding-import FastFunctions-import PlainPanic-import Util--import Control.Concurrent.MVar-import Control.DeepSeq-import Control.Monad-import Data.ByteString (ByteString)-import qualified Data.ByteString          as BS-import qualified Data.ByteString.Char8    as BSC-import qualified Data.ByteString.Internal as BS-import qualified Data.ByteString.Unsafe   as BS-import Foreign.C-import GHC.Exts-import System.IO-import Data.Data-import Data.IORef-import Data.Char-import Data.Semigroup as Semi--import GHC.IO--import Foreign--#if GHC_STAGE >= 2-import GHC.Conc.Sync    (sharedCAF)-#endif--import GHC.Base         ( unpackCString#, unpackNBytes# )----- | Gives the UTF-8 encoded bytes corresponding to a 'FastString'-bytesFS :: FastString -> ByteString-bytesFS f = fs_bs f--{-# DEPRECATED fastStringToByteString "Use `bytesFS` instead" #-}-fastStringToByteString :: FastString -> ByteString-fastStringToByteString = bytesFS--fastZStringToByteString :: FastZString -> ByteString-fastZStringToByteString (FastZString bs) = bs---- This will drop information if any character > '\xFF'-unsafeMkByteString :: String -> ByteString-unsafeMkByteString = BSC.pack--hashFastString :: FastString -> Int-hashFastString (FastString _ _ bs _)-    = inlinePerformIO $ BS.unsafeUseAsCStringLen bs $ \(ptr, len) ->-      return $ hashStr (castPtr ptr) len---- -------------------------------------------------------------------------------newtype FastZString = FastZString ByteString-  deriving NFData--hPutFZS :: Handle -> FastZString -> IO ()-hPutFZS handle (FastZString bs) = BS.hPut handle bs--zString :: FastZString -> String-zString (FastZString bs) =-    inlinePerformIO $ BS.unsafeUseAsCStringLen bs peekCAStringLen--lengthFZS :: FastZString -> Int-lengthFZS (FastZString bs) = BS.length bs--mkFastZStringString :: String -> FastZString-mkFastZStringString str = FastZString (BSC.pack str)---- -------------------------------------------------------------------------------{-| A 'FastString' is a UTF-8 encoded string together with a unique ID. All-'FastString's are stored in a global hashtable to support fast O(1)-comparison.--It is also associated with a lazy reference to the Z-encoding-of this string which is used by the compiler internally.--}-data FastString = FastString {-      uniq    :: {-# UNPACK #-} !Int, -- unique id-      n_chars :: {-# UNPACK #-} !Int, -- number of chars-      fs_bs   :: {-# UNPACK #-} !ByteString,-      fs_zenc :: FastZString-      -- ^ Lazily computed z-encoding of this string.-      ---      -- Since 'FastString's are globally memoized this is computed at most-      -- once for any given string.-  }--instance Eq FastString where-  f1 == f2  =  uniq f1 == uniq f2--instance Ord FastString where-    -- Compares lexicographically, not by unique-    a <= b = case cmpFS a b of { LT -> True;  EQ -> True;  GT -> False }-    a <  b = case cmpFS a b of { LT -> True;  EQ -> False; GT -> False }-    a >= b = case cmpFS a b of { LT -> False; EQ -> True;  GT -> True  }-    a >  b = case cmpFS a b of { LT -> False; EQ -> False; GT -> True  }-    max x y | x >= y    =  x-            | otherwise =  y-    min x y | x <= y    =  x-            | otherwise =  y-    compare a b = cmpFS a b--instance IsString FastString where-    fromString = fsLit--instance Semi.Semigroup FastString where-    (<>) = appendFS--instance Monoid FastString where-    mempty = nilFS-    mappend = (Semi.<>)-    mconcat = concatFS--instance Show FastString where-   show fs = show (unpackFS fs)--instance Data FastString where-  -- don't traverse?-  toConstr _   = abstractConstr "FastString"-  gunfold _ _  = error "gunfold"-  dataTypeOf _ = mkNoRepType "FastString"--instance NFData FastString where-  rnf fs = seq fs ()--cmpFS :: FastString -> FastString -> Ordering-cmpFS f1@(FastString u1 _ _ _) f2@(FastString u2 _ _ _) =-  if u1 == u2 then EQ else-  compare (bytesFS f1) (bytesFS f2)--foreign import ccall unsafe "memcmp"-  memcmp :: Ptr a -> Ptr b -> Int -> IO Int---- -------------------------------------------------------------------------------- Construction--{--Internally, the compiler will maintain a fast string symbol table, providing-sharing and fast comparison. Creation of new @FastString@s then covertly does a-lookup, re-using the @FastString@ if there was a hit.--The design of the FastString hash table allows for lockless concurrent reads-and updates to multiple buckets with low synchronization overhead.--See Note [Updating the FastString table] on how it's updated.--}-data FastStringTable = FastStringTable-  {-# UNPACK #-} !(IORef Int) -- the unique ID counter shared with all buckets-  {-# UNPACK #-} !(IORef Int) -- number of computed z-encodings for all buckets-  (Array# (IORef FastStringTableSegment)) -- concurrent segments--data FastStringTableSegment = FastStringTableSegment-  {-# UNPACK #-} !(MVar ()) -- the lock for write in each segment-  {-# UNPACK #-} !(IORef Int) -- the number of elements-  (MutableArray# RealWorld [FastString]) -- buckets in this segment--{--Following parameters are determined based on:--* Benchmark based on testsuite/tests/utils/should_run/T14854.hs-* Stats of @echo :browse | ghc --interactive -dfaststring-stats >/dev/null@:-  on 2018-10-24, we have 13920 entries.--}-segmentBits, numSegments, segmentMask, initialNumBuckets :: Int-segmentBits = 8-numSegments = 256   -- bit segmentBits-segmentMask = 0xff  -- bit segmentBits - 1-initialNumBuckets = 64--hashToSegment# :: Int# -> Int#-hashToSegment# hash# = hash# `andI#` segmentMask#-  where-    !(I# segmentMask#) = segmentMask--hashToIndex# :: MutableArray# RealWorld [FastString] -> Int# -> Int#-hashToIndex# buckets# hash# =-  (hash# `uncheckedIShiftRL#` segmentBits#) `remInt#` size#-  where-    !(I# segmentBits#) = segmentBits-    size# = sizeofMutableArray# buckets#--maybeResizeSegment :: IORef FastStringTableSegment -> IO FastStringTableSegment-maybeResizeSegment segmentRef = do-  segment@(FastStringTableSegment lock counter old#) <- readIORef segmentRef-  let oldSize# = sizeofMutableArray# old#-      newSize# = oldSize# *# 2#-  (I# n#) <- readIORef counter-  if isTrue# (n# <# newSize#) -- maximum load of 1-  then return segment-  else do-    resizedSegment@(FastStringTableSegment _ _ new#) <- IO $ \s1# ->-      case newArray# newSize# [] s1# of-        (# s2#, arr# #) -> (# s2#, FastStringTableSegment lock counter arr# #)-    forM_ [0 .. (I# oldSize#) - 1] $ \(I# i#) -> do-      fsList <- IO $ readArray# old# i#-      forM_ fsList $ \fs -> do-        let -- Shall we store in hash value in FastString instead?-            !(I# hash#) = hashFastString fs-            idx# = hashToIndex# new# hash#-        IO $ \s1# ->-          case readArray# new# idx# s1# of-            (# s2#, bucket #) -> case writeArray# new# idx# (fs: bucket) s2# of-              s3# -> (# s3#, () #)-    writeIORef segmentRef resizedSegment-    return resizedSegment--{-# NOINLINE stringTable #-}-stringTable :: FastStringTable-stringTable = unsafePerformIO $ do-  let !(I# numSegments#) = numSegments-      !(I# initialNumBuckets#) = initialNumBuckets-      loop a# i# s1#-        | isTrue# (i# ==# numSegments#) = s1#-        | otherwise = case newMVar () `unIO` s1# of-            (# s2#, lock #) -> case newIORef 0 `unIO` s2# of-              (# s3#, counter #) -> case newArray# initialNumBuckets# [] s3# of-                (# s4#, buckets# #) -> case newIORef-                    (FastStringTableSegment lock counter buckets#) `unIO` s4# of-                  (# s5#, segment #) -> case writeArray# a# i# segment s5# of-                    s6# -> loop a# (i# +# 1#) s6#-  uid <- newIORef 603979776 -- ord '$' * 0x01000000-  n_zencs <- newIORef 0-  tab <- IO $ \s1# ->-    case newArray# numSegments# (panic "string_table") s1# of-      (# s2#, arr# #) -> case loop arr# 0# s2# of-        s3# -> case unsafeFreezeArray# arr# s3# of-          (# s4#, segments# #) ->-            (# s4#, FastStringTable uid n_zencs segments# #)--  -- use the support wired into the RTS to share this CAF among all images of-  -- libHSghc-#if GHC_STAGE < 2-  return tab-#else-  sharedCAF tab getOrSetLibHSghcFastStringTable---- from the RTS; thus we cannot use this mechanism when GHC_STAGE<2; the previous--- RTS might not have this symbol-foreign import ccall unsafe "getOrSetLibHSghcFastStringTable"-  getOrSetLibHSghcFastStringTable :: Ptr a -> IO (Ptr a)-#endif--{---We include the FastString table in the `sharedCAF` mechanism because we'd like-FastStrings created by a Core plugin to have the same uniques as corresponding-strings created by the host compiler itself.  For example, this allows plugins-to lookup known names (eg `mkTcOcc "MySpecialType"`) in the GlobalRdrEnv or-even re-invoke the parser.--In particular, the following little sanity test was failing in a plugin-prototyping safe newtype-coercions: GHC.NT.Type.NT was imported, but could not-be looked up /by the plugin/.--   let rdrName = mkModuleName "GHC.NT.Type" `mkRdrQual` mkTcOcc "NT"-   putMsgS $ showSDoc dflags $ ppr $ lookupGRE_RdrName rdrName $ mg_rdr_env guts--`mkTcOcc` involves the lookup (or creation) of a FastString.  Since the-plugin's FastString.string_table is empty, constructing the RdrName also-allocates new uniques for the FastStrings "GHC.NT.Type" and "NT".  These-uniques are almost certainly unequal to the ones that the host compiler-originally assigned to those FastStrings.  Thus the lookup fails since the-domain of the GlobalRdrEnv is affected by the RdrName's OccName's FastString's-unique.--Maintaining synchronization of the two instances of this global is rather-difficult because of the uses of `unsafePerformIO` in this module.  Not-synchronizing them risks breaking the rather major invariant that two-FastStrings with the same unique have the same string. Thus we use the-lower-level `sharedCAF` mechanism that relies on Globals.c.---}--mkFastString# :: Addr# -> FastString-mkFastString# a# = mkFastStringBytes ptr (ptrStrLength ptr)-  where ptr = Ptr a#--{- Note [Updating the FastString table]--We use a concurrent hashtable which contains multiple segments, each hash value-always maps to the same segment. Read is lock-free, write to the a segment-should acquire a lock for that segment to avoid race condition, writes to-different segments are independent.--The procedure goes like this:--1. Find out which segment to operate on based on the hash value-2. Read the relevant bucket and perform a look up of the string.-3. If it exists, return it.-4. Otherwise grab a unique ID, create a new FastString and atomically attempt-   to update the relevant segment with this FastString:--   * Resize the segment by doubling the number of buckets when the number of-     FastStrings in this segment grows beyond the threshold.-   * Double check that the string is not in the bucket. Another thread may have-     inserted it while we were creating our string.-   * Return the existing FastString if it exists. The one we preemptively-     created will get GCed.-   * Otherwise, insert and return the string we created.--}--mkFastStringWith-    :: (Int -> IORef Int-> IO FastString) -> Ptr Word8 -> Int -> IO FastString-mkFastStringWith mk_fs !ptr !len = do-  FastStringTableSegment lock _ buckets# <- readIORef segmentRef-  let idx# = hashToIndex# buckets# hash#-  bucket <- IO $ readArray# buckets# idx#-  res <- bucket_match bucket len ptr-  case res of-    Just found -> return found-    Nothing -> do-      -- The withMVar below is not dupable. It can lead to deadlock if it is-      -- only run partially and putMVar is not called after takeMVar.-      noDuplicate-      n <- get_uid-      new_fs <- mk_fs n n_zencs-      withMVar lock $ \_ -> insert new_fs-  where-    !(FastStringTable uid n_zencs segments#) = stringTable-    get_uid = atomicModifyIORef' uid $ \n -> (n+1,n)--    !(I# hash#) = hashStr ptr len-    (# segmentRef #) = indexArray# segments# (hashToSegment# hash#)-    insert fs = do-      FastStringTableSegment _ counter buckets# <- maybeResizeSegment segmentRef-      let idx# = hashToIndex# buckets# hash#-      bucket <- IO $ readArray# buckets# idx#-      res <- bucket_match bucket len ptr-      case res of-        -- The FastString was added by another thread after previous read and-        -- before we acquired the write lock.-        Just found -> return found-        Nothing -> do-          IO $ \s1# ->-            case writeArray# buckets# idx# (fs: bucket) s1# of-              s2# -> (# s2#, () #)-          modifyIORef' counter succ-          return fs--bucket_match :: [FastString] -> Int -> Ptr Word8 -> IO (Maybe FastString)-bucket_match [] _ _ = return Nothing-bucket_match (v@(FastString _ _ bs _):ls) len ptr-      | len == BS.length bs = do-         b <- BS.unsafeUseAsCString bs $ \buf ->-             cmpStringPrefix ptr (castPtr buf) len-         if b then return (Just v)-              else bucket_match ls len ptr-      | otherwise =-         bucket_match ls len ptr--mkFastStringBytes :: Ptr Word8 -> Int -> FastString-mkFastStringBytes !ptr !len =-    -- NB: Might as well use unsafeDupablePerformIO, since mkFastStringWith is-    -- idempotent.-    unsafeDupablePerformIO $-        mkFastStringWith (copyNewFastString ptr len) ptr len---- | Create a 'FastString' from an existing 'ForeignPtr'; the difference--- between this and 'mkFastStringBytes' is that we don't have to copy--- the bytes if the string is new to the table.-mkFastStringForeignPtr :: Ptr Word8 -> ForeignPtr Word8 -> Int -> IO FastString-mkFastStringForeignPtr ptr !fp len-    = mkFastStringWith (mkNewFastString fp ptr len) ptr len---- | Create a 'FastString' from an existing 'ForeignPtr'; the difference--- between this and 'mkFastStringBytes' is that we don't have to copy--- the bytes if the string is new to the table.-mkFastStringByteString :: ByteString -> FastString-mkFastStringByteString bs =-    inlinePerformIO $-      BS.unsafeUseAsCStringLen bs $ \(ptr, len) -> do-        let ptr' = castPtr ptr-        mkFastStringWith (mkNewFastStringByteString bs ptr' len) ptr' len---- | Creates a UTF-8 encoded 'FastString' from a 'String'-mkFastString :: String -> FastString-mkFastString str =-  inlinePerformIO $ do-    let l = utf8EncodedLength str-    buf <- mallocForeignPtrBytes l-    withForeignPtr buf $ \ptr -> do-      utf8EncodeString ptr str-      mkFastStringForeignPtr ptr buf l---- | Creates a 'FastString' from a UTF-8 encoded @[Word8]@-mkFastStringByteList :: [Word8] -> FastString-mkFastStringByteList str = mkFastStringByteString (BS.pack str)---- | Creates a (lazy) Z-encoded 'FastString' from a 'String' and account--- the number of forced z-strings into the passed 'IORef'.-mkZFastString :: IORef Int -> ByteString -> FastZString-mkZFastString n_zencs bs = unsafePerformIO $ do-  atomicModifyIORef' n_zencs $ \n -> (n+1, ())-  return $ mkFastZStringString (zEncodeString (utf8DecodeByteString bs))--mkNewFastString :: ForeignPtr Word8 -> Ptr Word8 -> Int -> Int-                -> IORef Int -> IO FastString-mkNewFastString fp ptr len uid n_zencs = do-  let bs = BS.fromForeignPtr fp 0 len-      zstr = mkZFastString n_zencs bs-  n_chars <- countUTF8Chars ptr len-  return (FastString uid n_chars bs zstr)--mkNewFastStringByteString :: ByteString -> Ptr Word8 -> Int -> Int-                          -> IORef Int -> IO FastString-mkNewFastStringByteString bs ptr len uid n_zencs = do-  let zstr = mkZFastString n_zencs bs-  n_chars <- countUTF8Chars ptr len-  return (FastString uid n_chars bs zstr)--copyNewFastString :: Ptr Word8 -> Int -> Int -> IORef Int -> IO FastString-copyNewFastString ptr len uid n_zencs = do-  fp <- copyBytesToForeignPtr ptr len-  let bs = BS.fromForeignPtr fp 0 len-      zstr = mkZFastString n_zencs bs-  n_chars <- countUTF8Chars ptr len-  return (FastString uid n_chars bs zstr)--copyBytesToForeignPtr :: Ptr Word8 -> Int -> IO (ForeignPtr Word8)-copyBytesToForeignPtr ptr len = do-  fp <- mallocForeignPtrBytes len-  withForeignPtr fp $ \ptr' -> copyBytes ptr' ptr len-  return fp--cmpStringPrefix :: Ptr Word8 -> Ptr Word8 -> Int -> IO Bool-cmpStringPrefix ptr1 ptr2 len =- do r <- memcmp ptr1 ptr2 len-    return (r == 0)--hashStr  :: Ptr Word8 -> Int -> Int- -- use the Addr to produce a hash value between 0 & m (inclusive)-hashStr (Ptr a#) (I# len#) = loop 0# 0#-  where-    loop h n =-      if isTrue# (n ==# len#) then-        I# h-      else-        let-          -- DO NOT move this let binding! indexCharOffAddr# reads from the-          -- pointer so we need to evaluate this based on the length check-          -- above. Not doing this right caused #17909.-          !c = ord# (indexCharOffAddr# a# n)-          !h2 = (h *# 16777619#) `xorI#` c-        in-          loop h2 (n +# 1#)---- -------------------------------------------------------------------------------- Operations---- | Returns the length of the 'FastString' in characters-lengthFS :: FastString -> Int-lengthFS f = n_chars f---- | Returns @True@ if the 'FastString' is empty-nullFS :: FastString -> Bool-nullFS f = BS.null (fs_bs f)---- | Unpacks and decodes the FastString-unpackFS :: FastString -> String-unpackFS (FastString _ _ bs _) = utf8DecodeByteString bs---- | Returns a Z-encoded version of a 'FastString'.  This might be the--- original, if it was already Z-encoded.  The first time this--- function is applied to a particular 'FastString', the results are--- memoized.----zEncodeFS :: FastString -> FastZString-zEncodeFS (FastString _ _ _ ref) = ref--appendFS :: FastString -> FastString -> FastString-appendFS fs1 fs2 = mkFastStringByteString-                 $ BS.append (bytesFS fs1) (bytesFS fs2)--concatFS :: [FastString] -> FastString-concatFS = mkFastStringByteString . BS.concat . map fs_bs--headFS :: FastString -> Char-headFS (FastString _ 0 _ _) = panic "headFS: Empty FastString"-headFS (FastString _ _ bs _) =-  inlinePerformIO $ BS.unsafeUseAsCString bs $ \ptr ->-         return (fst (utf8DecodeChar (castPtr ptr)))--tailFS :: FastString -> FastString-tailFS (FastString _ 0 _ _) = panic "tailFS: Empty FastString"-tailFS (FastString _ _ bs _) =-    inlinePerformIO $ BS.unsafeUseAsCString bs $ \ptr ->-    do let (_, n) = utf8DecodeChar (castPtr ptr)-       return $! mkFastStringByteString (BS.drop n bs)--consFS :: Char -> FastString -> FastString-consFS c fs = mkFastString (c : unpackFS fs)--uniqueOfFS :: FastString -> Int-uniqueOfFS (FastString u _ _ _) = u--nilFS :: FastString-nilFS = mkFastString ""--isUnderscoreFS :: FastString -> Bool-isUnderscoreFS fs = fs == fsLit "_"---- -------------------------------------------------------------------------------- Stats--getFastStringTable :: IO [[[FastString]]]-getFastStringTable =-  forM [0 .. numSegments - 1] $ \(I# i#) -> do-    let (# segmentRef #) = indexArray# segments# i#-    FastStringTableSegment _ _ buckets# <- readIORef segmentRef-    let bucketSize = I# (sizeofMutableArray# buckets#)-    forM [0 .. bucketSize - 1] $ \(I# j#) ->-      IO $ readArray# buckets# j#-  where-    !(FastStringTable _ _ segments#) = stringTable--getFastStringZEncCounter :: IO Int-getFastStringZEncCounter = readIORef n_zencs-  where-    !(FastStringTable _ n_zencs _) = stringTable---- -------------------------------------------------------------------------------- Outputting 'FastString's---- |Outputs a 'FastString' with /no decoding at all/, that is, you--- get the actual bytes in the 'FastString' written to the 'Handle'.-hPutFS :: Handle -> FastString -> IO ()-hPutFS handle fs = BS.hPut handle $ bytesFS fs---- ToDo: we'll probably want an hPutFSLocal, or something, to output--- in the current locale's encoding (for error messages and suchlike).---- -------------------------------------------------------------------------------- PtrStrings, here for convenience only.---- | A 'PtrString' is a pointer to some array of Latin-1 encoded chars.-data PtrString = PtrString !(Ptr Word8) !Int---- | Wrap an unboxed address into a 'PtrString'.-mkPtrString# :: Addr# -> PtrString-mkPtrString# a# = PtrString (Ptr a#) (ptrStrLength (Ptr a#))---- | Encode a 'String' into a newly allocated 'PtrString' using Latin-1--- encoding.  The original string must not contain non-Latin-1 characters--- (above codepoint @0xff@).-{-# INLINE mkPtrString #-}-mkPtrString :: String -> PtrString-mkPtrString s =- -- we don't use `unsafeDupablePerformIO` here to avoid potential memory leaks- -- and because someone might be using `eqAddr#` to check for string equality.- unsafePerformIO (do-   let len = length s-   p <- mallocBytes len-   let-     loop :: Int -> String -> IO ()-     loop !_ []    = return ()-     loop n (c:cs) = do-        pokeByteOff p n (fromIntegral (ord c) :: Word8)-        loop (1+n) cs-   loop 0 s-   return (PtrString p len)- )---- | Decode a 'PtrString' back into a 'String' using Latin-1 encoding.--- This does not free the memory associated with 'PtrString'.-unpackPtrString :: PtrString -> String-unpackPtrString (PtrString (Ptr p#) (I# n#)) = unpackNBytes# p# n#---- | Return the length of a 'PtrString'-lengthPS :: PtrString -> Int-lengthPS (PtrString _ n) = n---- -------------------------------------------------------------------------------- under the carpet--foreign import ccall unsafe "strlen"-  ptrStrLength :: Ptr Word8 -> Int--{-# NOINLINE sLit #-}-sLit :: String -> PtrString-sLit x  = mkPtrString x--{-# NOINLINE fsLit #-}-fsLit :: String -> FastString-fsLit x = mkFastString x--{-# RULES "slit"-    forall x . sLit  (unpackCString# x) = mkPtrString#  x #-}-{-# RULES "fslit"-    forall x . fsLit (unpackCString# x) = mkFastString# x #-}
− compiler/utils/FastStringEnv.hs 
@@ -1,100 +0,0 @@-{--%-% (c) The University of Glasgow 2006-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998-%-\section[FastStringEnv]{@FastStringEnv@: FastString environments}--}--module FastStringEnv (-        -- * FastString environments (maps)-        FastStringEnv,--        -- ** Manipulating these environments-        mkFsEnv,-        emptyFsEnv, unitFsEnv,-        extendFsEnv_C, extendFsEnv_Acc, extendFsEnv,-        extendFsEnvList, extendFsEnvList_C,-        filterFsEnv,-        plusFsEnv, plusFsEnv_C, alterFsEnv,-        lookupFsEnv, lookupFsEnv_NF, delFromFsEnv, delListFromFsEnv,-        elemFsEnv, mapFsEnv,--        -- * Deterministic FastString environments (maps)-        DFastStringEnv,--        -- ** Manipulating these environments-        mkDFsEnv, emptyDFsEnv, dFsEnvElts, lookupDFsEnv-    ) where--import GhcPrelude--import GHC.Types.Unique.FM-import GHC.Types.Unique.DFM-import Maybes-import FastString----- | A non-deterministic set of FastStrings.--- See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not--- deterministic and why it matters. Use DFastStringEnv if the set eventually--- gets converted into a list or folded over in a way where the order--- changes the generated code.-type FastStringEnv a = UniqFM a  -- Domain is FastString--emptyFsEnv         :: FastStringEnv a-mkFsEnv            :: [(FastString,a)] -> FastStringEnv a-alterFsEnv         :: (Maybe a-> Maybe a) -> FastStringEnv a -> FastString -> FastStringEnv a-extendFsEnv_C      :: (a->a->a) -> FastStringEnv a -> FastString -> a -> FastStringEnv a-extendFsEnv_Acc    :: (a->b->b) -> (a->b) -> FastStringEnv b -> FastString -> a -> FastStringEnv b-extendFsEnv        :: FastStringEnv a -> FastString -> a -> FastStringEnv a-plusFsEnv          :: FastStringEnv a -> FastStringEnv a -> FastStringEnv a-plusFsEnv_C        :: (a->a->a) -> FastStringEnv a -> FastStringEnv a -> FastStringEnv a-extendFsEnvList    :: FastStringEnv a -> [(FastString,a)] -> FastStringEnv a-extendFsEnvList_C  :: (a->a->a) -> FastStringEnv a -> [(FastString,a)] -> FastStringEnv a-delFromFsEnv       :: FastStringEnv a -> FastString -> FastStringEnv a-delListFromFsEnv   :: FastStringEnv a -> [FastString] -> FastStringEnv a-elemFsEnv          :: FastString -> FastStringEnv a -> Bool-unitFsEnv          :: FastString -> a -> FastStringEnv a-lookupFsEnv        :: FastStringEnv a -> FastString -> Maybe a-lookupFsEnv_NF     :: FastStringEnv a -> FastString -> a-filterFsEnv        :: (elt -> Bool) -> FastStringEnv elt -> FastStringEnv elt-mapFsEnv           :: (elt1 -> elt2) -> FastStringEnv elt1 -> FastStringEnv elt2--emptyFsEnv                = emptyUFM-unitFsEnv x y             = unitUFM x y-extendFsEnv x y z         = addToUFM x y z-extendFsEnvList x l       = addListToUFM x l-lookupFsEnv x y           = lookupUFM x y-alterFsEnv                = alterUFM-mkFsEnv     l             = listToUFM l-elemFsEnv x y             = elemUFM x y-plusFsEnv x y             = plusUFM x y-plusFsEnv_C f x y         = plusUFM_C f x y-extendFsEnv_C f x y z     = addToUFM_C f x y z-mapFsEnv f x              = mapUFM f x-extendFsEnv_Acc x y z a b = addToUFM_Acc x y z a b-extendFsEnvList_C x y z   = addListToUFM_C x y z-delFromFsEnv x y          = delFromUFM x y-delListFromFsEnv x y      = delListFromUFM x y-filterFsEnv x y           = filterUFM x y--lookupFsEnv_NF env n = expectJust "lookupFsEnv_NF" (lookupFsEnv env n)---- Deterministic FastStringEnv--- See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why we need--- DFastStringEnv.--type DFastStringEnv a = UniqDFM a  -- Domain is FastString--emptyDFsEnv :: DFastStringEnv a-emptyDFsEnv = emptyUDFM--dFsEnvElts :: DFastStringEnv a -> [a]-dFsEnvElts = eltsUDFM--mkDFsEnv :: [(FastString,a)] -> DFastStringEnv a-mkDFsEnv l = listToUDFM l--lookupDFsEnv :: DFastStringEnv a -> FastString -> Maybe a-lookupDFsEnv = lookupUDFM
− compiler/utils/Fingerprint.hs 
@@ -1,47 +0,0 @@-{-# LANGUAGE CPP #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}---- ----------------------------------------------------------------------------------  (c) The University of Glasgow 2006------ Fingerprints for recompilation checking and ABI versioning.------ https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidance------ ------------------------------------------------------------------------------module Fingerprint (-        readHexFingerprint,-        fingerprintByteString,-        -- * Re-exported from GHC.Fingerprint-        Fingerprint(..), fingerprint0,-        fingerprintFingerprints,-        fingerprintData,-        fingerprintString,-        getFileHash-   ) where--#include "HsVersions.h"--import GhcPrelude--import Foreign-import GHC.IO-import Numeric          ( readHex )--import qualified Data.ByteString as BS-import qualified Data.ByteString.Unsafe as BS--import GHC.Fingerprint---- useful for parsing the output of 'md5sum', should we want to do that.-readHexFingerprint :: String -> Fingerprint-readHexFingerprint s = Fingerprint w1 w2- where (s1,s2) = splitAt 16 s-       [(w1,"")] = readHex s1-       [(w2,"")] = readHex (take 16 s2)--fingerprintByteString :: BS.ByteString -> Fingerprint-fingerprintByteString bs = unsafeDupablePerformIO $-  BS.unsafeUseAsCStringLen bs $ \(ptr, len) -> fingerprintData (castPtr ptr) len
− compiler/utils/FiniteMap.hs 
@@ -1,31 +0,0 @@--- Some extra functions to extend Data.Map--module FiniteMap (-        insertList,-        insertListWith,-        deleteList,-        foldRight, foldRightWithKey-    ) where--import GhcPrelude--import Data.Map (Map)-import qualified Data.Map as Map--insertList :: Ord key => [(key,elt)] -> Map key elt -> Map key elt-insertList xs m = foldl' (\m (k, v) -> Map.insert k v m) m xs--insertListWith :: Ord key-               => (elt -> elt -> elt)-               -> [(key,elt)]-               -> Map key elt-               -> Map key elt-insertListWith f xs m0 = foldl' (\m (k, v) -> Map.insertWith f k v m) m0 xs--deleteList :: Ord key => [key] -> Map key elt -> Map key elt-deleteList ks m = foldl' (flip Map.delete) m ks--foldRight        :: (elt -> a -> a) -> a -> Map key elt -> a-foldRight        = Map.foldr-foldRightWithKey :: (key -> elt -> a -> a) -> a -> Map key elt -> a-foldRightWithKey = Map.foldrWithKey
− compiler/utils/GhcPrelude.hs 
@@ -1,33 +0,0 @@-{-# LANGUAGE CPP #-}---- | Custom GHC "Prelude"------ This module serves as a replacement for the "Prelude" module--- and abstracts over differences between the bootstrapping--- GHC version, and may also provide a common default vocabulary.---- Every module in GHC---   * Is compiled with -XNoImplicitPrelude---   * Explicitly imports GhcPrelude--module GhcPrelude (module X) where---- We export the 'Semigroup' class but w/o the (<>) operator to avoid--- clashing with the (Outputable.<>) operator which is heavily used--- through GHC's code-base.--import Prelude as X hiding ((<>))-import Data.Foldable as X (foldl')--{--Note [Why do we import Prelude here?]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-The files ghc-boot-th.cabal, ghc-boot.cabal, ghci.cabal and-ghc-heap.cabal contain the directive default-extensions:-NoImplicitPrelude. There are two motivations for this:-  - Consistency with the compiler directory, which enables-    NoImplicitPrelude;-  - Allows loading the above dependent packages with ghc-in-ghci,-    giving a smoother development experience when adding new-    extensions.--}
− compiler/utils/IOEnv.hs 
@@ -1,219 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveFunctor #-}------ (c) The University of Glasgow 2002-2006------ The IO Monad with an environment------ The environment is passed around as a Reader monad but--- as its in the IO monad, mutable references can be used--- for updating state.-----module IOEnv (-        IOEnv, -- Instance of Monad--        -- Monad utilities-        module MonadUtils,--        -- Errors-        failM, failWithM,-        IOEnvFailure(..),--        -- Getting at the environment-        getEnv, setEnv, updEnv,--        runIOEnv, unsafeInterleaveM, uninterruptibleMaskM_,-        tryM, tryAllM, tryMostM, fixM,--        -- I/O operations-        IORef, newMutVar, readMutVar, writeMutVar, updMutVar,-        atomicUpdMutVar, atomicUpdMutVar'-  ) where--import GhcPrelude--import GHC.Driver.Session-import Exception-import GHC.Types.Module-import Panic--import Data.IORef       ( IORef, newIORef, readIORef, writeIORef, modifyIORef,-                          atomicModifyIORef, atomicModifyIORef' )-import System.IO.Unsafe ( unsafeInterleaveIO )-import System.IO        ( fixIO )-import Control.Monad-import MonadUtils-import Control.Applicative (Alternative(..))--------------------------------------------------------------------------- Defining the monad type--------------------------------------------------------------------------newtype IOEnv env a = IOEnv (env -> IO a) deriving (Functor)--unIOEnv :: IOEnv env a -> (env -> IO a)-unIOEnv (IOEnv m) = m--instance Monad (IOEnv m) where-    (>>=)  = thenM-    (>>)   = (*>)--instance MonadFail (IOEnv m) where-    fail _ = failM -- Ignore the string--instance Applicative (IOEnv m) where-    pure = returnM-    IOEnv f <*> IOEnv x = IOEnv (\ env -> f env <*> x env )-    (*>) = thenM_--returnM :: a -> IOEnv env a-returnM a = IOEnv (\ _ -> return a)--thenM :: IOEnv env a -> (a -> IOEnv env b) -> IOEnv env b-thenM (IOEnv m) f = IOEnv (\ env -> do { r <- m env ;-                                         unIOEnv (f r) env })--thenM_ :: IOEnv env a -> IOEnv env b -> IOEnv env b-thenM_ (IOEnv m) f = IOEnv (\ env -> do { _ <- m env ; unIOEnv f env })--failM :: IOEnv env a-failM = IOEnv (\ _ -> throwIO IOEnvFailure)--failWithM :: String -> IOEnv env a-failWithM s = IOEnv (\ _ -> ioError (userError s))--data IOEnvFailure = IOEnvFailure--instance Show IOEnvFailure where-    show IOEnvFailure = "IOEnv failure"--instance Exception IOEnvFailure--instance ExceptionMonad (IOEnv a) where-  gcatch act handle =-      IOEnv $ \s -> unIOEnv act s `gcatch` \e -> unIOEnv (handle e) s-  gmask f =-      IOEnv $ \s -> gmask $ \io_restore ->-                             let-                                g_restore (IOEnv m) = IOEnv $ \s -> io_restore (m s)-                             in-                                unIOEnv (f g_restore) s--instance ContainsDynFlags env => HasDynFlags (IOEnv env) where-    getDynFlags = do env <- getEnv-                     return $! extractDynFlags env--instance ContainsModule env => HasModule (IOEnv env) where-    getModule = do env <- getEnv-                   return $ extractModule env--------------------------------------------------------------------------- Fundamental combinators specific to the monad------------------------------------------------------------------------------------------------------runIOEnv :: env -> IOEnv env a -> IO a-runIOEnv env (IOEnv m) = m env-------------------------------{-# NOINLINE fixM #-}-  -- Aargh!  Not inlining fixM alleviates a space leak problem.-  -- Normally fixM is used with a lazy tuple match: if the optimiser is-  -- shown the definition of fixM, it occasionally transforms the code-  -- in such a way that the code generator doesn't spot the selector-  -- thunks.  Sigh.--fixM :: (a -> IOEnv env a) -> IOEnv env a-fixM f = IOEnv (\ env -> fixIO (\ r -> unIOEnv (f r) env))-------------------------------tryM :: IOEnv env r -> IOEnv env (Either IOEnvFailure r)--- Reflect UserError exceptions (only) into IOEnv monad--- Other exceptions are not caught; they are simply propagated as exns------ The idea is that errors in the program being compiled will give rise--- to UserErrors.  But, say, pattern-match failures in GHC itself should--- not be caught here, else they'll be reported as errors in the program--- begin compiled!-tryM (IOEnv thing) = IOEnv (\ env -> tryIOEnvFailure (thing env))--tryIOEnvFailure :: IO a -> IO (Either IOEnvFailure a)-tryIOEnvFailure = try---- XXX We shouldn't be catching everything, e.g. timeouts-tryAllM :: IOEnv env r -> IOEnv env (Either SomeException r)--- Catch *all* exceptions--- This is used when running a Template-Haskell splice, when--- even a pattern-match failure is a programmer error-tryAllM (IOEnv thing) = IOEnv (\ env -> try (thing env))--tryMostM :: IOEnv env r -> IOEnv env (Either SomeException r)-tryMostM (IOEnv thing) = IOEnv (\ env -> tryMost (thing env))------------------------------unsafeInterleaveM :: IOEnv env a -> IOEnv env a-unsafeInterleaveM (IOEnv m) = IOEnv (\ env -> unsafeInterleaveIO (m env))--uninterruptibleMaskM_ :: IOEnv env a -> IOEnv env a-uninterruptibleMaskM_ (IOEnv m) = IOEnv (\ env -> uninterruptibleMask_ (m env))--------------------------------------------------------------------------- Alternative/MonadPlus-------------------------------------------------------------------------instance Alternative (IOEnv env) where-    empty   = IOEnv (const empty)-    m <|> n = IOEnv (\env -> unIOEnv m env <|> unIOEnv n env)--instance MonadPlus (IOEnv env)--------------------------------------------------------------------------- Accessing input/output-------------------------------------------------------------------------instance MonadIO (IOEnv env) where-    liftIO io = IOEnv (\ _ -> io)--newMutVar :: a -> IOEnv env (IORef a)-newMutVar val = liftIO (newIORef val)--writeMutVar :: IORef a -> a -> IOEnv env ()-writeMutVar var val = liftIO (writeIORef var val)--readMutVar :: IORef a -> IOEnv env a-readMutVar var = liftIO (readIORef var)--updMutVar :: IORef a -> (a -> a) -> IOEnv env ()-updMutVar var upd = liftIO (modifyIORef var upd)---- | Atomically update the reference.  Does not force the evaluation of the--- new variable contents.  For strict update, use 'atomicUpdMutVar''.-atomicUpdMutVar :: IORef a -> (a -> (a, b)) -> IOEnv env b-atomicUpdMutVar var upd = liftIO (atomicModifyIORef var upd)---- | Strict variant of 'atomicUpdMutVar'.-atomicUpdMutVar' :: IORef a -> (a -> (a, b)) -> IOEnv env b-atomicUpdMutVar' var upd = liftIO (atomicModifyIORef' var upd)--------------------------------------------------------------------------- Accessing the environment-------------------------------------------------------------------------getEnv :: IOEnv env env-{-# INLINE getEnv #-}-getEnv = IOEnv (\ env -> return env)---- | Perform a computation with a different environment-setEnv :: env' -> IOEnv env' a -> IOEnv env a-{-# INLINE setEnv #-}-setEnv new_env (IOEnv m) = IOEnv (\ _ -> m new_env)---- | Perform a computation with an altered environment-updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a-{-# INLINE updEnv #-}-updEnv upd (IOEnv m) = IOEnv (\ env -> m (upd env))
− compiler/utils/Json.hs 
@@ -1,56 +0,0 @@-{-# LANGUAGE GADTs #-}-module Json where--import GhcPrelude--import Outputable-import Data.Char-import Numeric---- | Simple data type to represent JSON documents.-data JsonDoc where-  JSNull :: JsonDoc-  JSBool :: Bool -> JsonDoc-  JSInt  :: Int  -> JsonDoc-  JSString :: String -> JsonDoc-  JSArray :: [JsonDoc] -> JsonDoc-  JSObject :: [(String, JsonDoc)] -> JsonDoc----- This is simple and slow as it is only used for error reporting-renderJSON :: JsonDoc -> SDoc-renderJSON d =-  case d of-    JSNull -> text "null"-    JSBool b -> text $ if b then "true" else "false"-    JSInt    n -> ppr n-    JSString s -> doubleQuotes $ text $ escapeJsonString s-    JSArray as -> brackets $ pprList renderJSON as-    JSObject fs -> braces $ pprList renderField fs-  where-    renderField :: (String, JsonDoc) -> SDoc-    renderField (s, j) = doubleQuotes (text s) <>  colon <+> renderJSON j--    pprList pp xs = hcat (punctuate comma (map pp xs))--escapeJsonString :: String -> String-escapeJsonString = concatMap escapeChar-  where-    escapeChar '\b' = "\\b"-    escapeChar '\f' = "\\f"-    escapeChar '\n' = "\\n"-    escapeChar '\r' = "\\r"-    escapeChar '\t' = "\\t"-    escapeChar '"'  = "\\\""-    escapeChar '\\'  = "\\\\"-    escapeChar c | isControl c || fromEnum c >= 0x7f  = uni_esc c-    escapeChar c = [c]--    uni_esc c = "\\u" ++ (pad 4 (showHex (fromEnum c) ""))--    pad n cs  | len < n   = replicate (n-len) '0' ++ cs-                          | otherwise = cs-                                   where len = length cs--class ToJson a where-  json :: a -> JsonDoc
− compiler/utils/ListSetOps.hs 
@@ -1,180 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--\section[ListSetOps]{Set-like operations on lists}--}--{-# LANGUAGE CPP #-}--module ListSetOps (-        unionLists, minusList, deleteBys,--        -- Association lists-        Assoc, assoc, assocMaybe, assocUsing, assocDefault, assocDefaultUsing,--        -- Duplicate handling-        hasNoDups, removeDups, findDupsEq,-        equivClasses,--        -- Indexing-        getNth-   ) where--#include "HsVersions.h"--import GhcPrelude--import Outputable-import Util--import qualified Data.List as L-import qualified Data.List.NonEmpty as NE-import Data.List.NonEmpty (NonEmpty(..))-import qualified Data.Set as S--getNth :: Outputable a => [a] -> Int -> a-getNth xs n = ASSERT2( xs `lengthExceeds` n, ppr n $$ ppr xs )-             xs !! n--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 (L.deleteBy eq)) xs ys--{--************************************************************************-*                                                                      *-        Treating lists as sets-        Assumes the lists contain no duplicates, but are unordered-*                                                                      *-************************************************************************--}----- | Assumes that the arguments contain no duplicates-unionLists :: (HasDebugCallStack, Outputable a, Eq a) => [a] -> [a] -> [a]--- We special case some reasonable common patterns.-unionLists xs [] = xs-unionLists [] ys = ys-unionLists [x] ys-  | isIn "unionLists" x ys = ys-  | otherwise = x:ys-unionLists xs [y]-  | isIn "unionLists" y xs = xs-  | otherwise = y:xs-unionLists xs ys-  = WARN(lengthExceeds xs 100 || lengthExceeds ys 100, ppr xs $$ ppr ys)-    [x | x <- xs, isn'tIn "unionLists" x ys] ++ ys---- | Calculate the set difference of two lists. This is--- /O((m + n) log n)/, where we subtract a list of /n/ elements--- from a list of /m/ elements.------ Extremely short cases are handled specially:--- When /m/ or /n/ is 0, this takes /O(1)/ time. When /m/ is 1,--- it takes /O(n)/ time.-minusList :: Ord a => [a] -> [a] -> [a]--- There's no point building a set to perform just one lookup, so we handle--- extremely short lists specially. It might actually be better to use--- an O(m*n) algorithm when m is a little longer (perhaps up to 4 or even 5).--- The tipping point will be somewhere in the area of where /m/ and /log n/--- become comparable, but we probably don't want to work too hard on this.-minusList [] _ = []-minusList xs@[x] ys-  | x `elem` ys = []-  | otherwise = xs--- Using an empty set or a singleton would also be silly, so let's not.-minusList xs [] = xs-minusList xs [y] = filter (/= y) xs--- When each list has at least two elements, we build a set from the--- second argument, allowing us to filter the first argument fairly--- efficiently.-minusList xs ys = filter (`S.notMember` yss) xs-  where-    yss = S.fromList ys--{--************************************************************************-*                                                                      *-\subsection[Utils-assoc]{Association lists}-*                                                                      *-************************************************************************--Inefficient finite maps based on association lists and equality.--}---- A finite mapping based on equality and association lists-type Assoc a b = [(a,b)]--assoc             :: (Eq a) => String -> Assoc a b -> a -> b-assocDefault      :: (Eq a) => b -> Assoc a b -> a -> b-assocUsing        :: (a -> a -> Bool) -> String -> Assoc a b -> a -> b-assocMaybe        :: (Eq a) => Assoc a b -> a -> Maybe b-assocDefaultUsing :: (a -> a -> Bool) -> b -> Assoc a b -> a -> b--assocDefaultUsing _  deflt []             _   = deflt-assocDefaultUsing eq deflt ((k,v) : rest) key-  | k `eq` key = v-  | otherwise  = assocDefaultUsing eq deflt rest key--assoc crash_msg         list key = assocDefaultUsing (==) (panic ("Failed in assoc: " ++ crash_msg)) list key-assocDefault deflt      list key = assocDefaultUsing (==) deflt list key-assocUsing eq crash_msg list key = assocDefaultUsing eq (panic ("Failed in assoc: " ++ crash_msg)) list key--assocMaybe alist key-  = lookup alist-  where-    lookup []             = Nothing-    lookup ((tv,ty):rest) = if key == tv then Just ty else lookup rest--{--************************************************************************-*                                                                      *-\subsection[Utils-dups]{Duplicate-handling}-*                                                                      *-************************************************************************--}--hasNoDups :: (Eq a) => [a] -> Bool--hasNoDups xs = f [] xs-  where-    f _           []     = True-    f seen_so_far (x:xs) = if x `is_elem` seen_so_far-                           then False-                           else f (x:seen_so_far) xs--    is_elem = isIn "hasNoDups"--equivClasses :: (a -> a -> Ordering) -- Comparison-             -> [a]-             -> [NonEmpty a]--equivClasses _   []      = []-equivClasses _   [stuff] = [stuff :| []]-equivClasses cmp items   = NE.groupBy eq (L.sortBy cmp items)-  where-    eq a b = case cmp a b of { EQ -> True; _ -> False }--removeDups :: (a -> a -> Ordering) -- Comparison function-           -> [a]-           -> ([a],          -- List with no duplicates-               [NonEmpty a]) -- List of duplicate groups.  One representative-                             -- from each group appears in the first result--removeDups _   []  = ([], [])-removeDups _   [x] = ([x],[])-removeDups cmp xs-  = case L.mapAccumR collect_dups [] (equivClasses cmp xs) of { (dups, xs') ->-    (xs', dups) }-  where-    collect_dups :: [NonEmpty a] -> NonEmpty a -> ([NonEmpty a], a)-    collect_dups dups_so_far (x :| [])     = (dups_so_far,      x)-    collect_dups dups_so_far dups@(x :| _) = (dups:dups_so_far, x)--findDupsEq :: (a->a->Bool) -> [a] -> [NonEmpty a]-findDupsEq _  [] = []-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/Maybes.hs 
@@ -1,114 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE FlexibleContexts #-}--{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--}--module Maybes (-        module Data.Maybe,--        MaybeErr(..), -- Instance of Monad-        failME, isSuccess,--        orElse,-        firstJust, firstJusts,-        whenIsJust,-        expectJust,-        rightToMaybe,--        -- * MaybeT-        MaybeT(..), liftMaybeT, tryMaybeT-    ) where--import GhcPrelude--import Control.Monad-import Control.Monad.Trans.Maybe-import Control.Exception (catch, SomeException(..))-import Data.Maybe-import Util (HasCallStack)--infixr 4 `orElse`--{--************************************************************************-*                                                                      *-\subsection[Maybe type]{The @Maybe@ type}-*                                                                      *-************************************************************************--}--firstJust :: Maybe a -> Maybe a -> Maybe a-firstJust a b = firstJusts [a, b]---- | Takes a list of @Maybes@ and returns the first @Just@ if there is one, or--- @Nothing@ otherwise.-firstJusts :: [Maybe a] -> Maybe a-firstJusts = msum--expectJust :: HasCallStack => String -> Maybe a -> a-{-# INLINE expectJust #-}-expectJust _   (Just x) = x-expectJust err Nothing  = error ("expectJust " ++ err)--whenIsJust :: Monad m => Maybe a -> (a -> m ()) -> m ()-whenIsJust (Just x) f = f x-whenIsJust Nothing  _ = return ()---- | Flipped version of @fromMaybe@, useful for chaining.-orElse :: Maybe a -> a -> a-orElse = flip fromMaybe--rightToMaybe :: Either a b -> Maybe b-rightToMaybe (Left _)  = Nothing-rightToMaybe (Right x) = Just x--{--************************************************************************-*                                                                      *-\subsection[MaybeT type]{The @MaybeT@ monad transformer}-*                                                                      *-************************************************************************--}---- We had our own MaybeT in the past. Now we reuse transformer's MaybeT--liftMaybeT :: Monad m => m a -> MaybeT m a-liftMaybeT act = MaybeT $ Just `liftM` act---- | Try performing an 'IO' action, failing on error.-tryMaybeT :: IO a -> MaybeT IO a-tryMaybeT action = MaybeT $ catch (Just `fmap` action) handler-  where-    handler (SomeException _) = return Nothing--{--************************************************************************-*                                                                      *-\subsection[MaybeErr type]{The @MaybeErr@ type}-*                                                                      *-************************************************************************--}--data MaybeErr err val = Succeeded val | Failed err-    deriving (Functor)--instance Applicative (MaybeErr err) where-  pure  = Succeeded-  (<*>) = ap--instance Monad (MaybeErr err) where-  Succeeded v >>= k = k v-  Failed e    >>= _ = Failed e--isSuccess :: MaybeErr err val -> Bool-isSuccess (Succeeded {}) = True-isSuccess (Failed {})    = False--failME :: err -> MaybeErr err val-failME e = Failed e
− compiler/utils/MonadUtils.hs 
@@ -1,215 +0,0 @@--- | Utilities related to Monad and Applicative classes---   Mostly for backwards compatibility.--module MonadUtils-        ( Applicative(..)-        , (<$>)--        , MonadFix(..)-        , MonadIO(..)--        , zipWith3M, zipWith3M_, zipWith4M, zipWithAndUnzipM-        , mapAndUnzipM, mapAndUnzip3M, mapAndUnzip4M, mapAndUnzip5M-        , mapAccumLM-        , mapSndM-        , concatMapM-        , mapMaybeM-        , fmapMaybeM, fmapEitherM-        , anyM, allM, orM-        , foldlM, foldlM_, foldrM-        , maybeMapM-        , whenM, unlessM-        , filterOutM-        ) where------------------------------------------------------------------------------------ Imports----------------------------------------------------------------------------------import GhcPrelude--import Control.Applicative-import Control.Monad-import Control.Monad.Fix-import Control.Monad.IO.Class-import Data.Foldable (sequenceA_, foldlM, foldrM)-import Data.List (unzip4, unzip5, zipWith4)------------------------------------------------------------------------------------ Common functions---  These are used throughout the compiler----------------------------------------------------------------------------------{---Note [Inline @zipWithNM@ functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--The inline principle for 'zipWith3M', 'zipWith4M' and 'zipWith3M_' is the same-as for 'zipWithM' and 'zipWithM_' in "Control.Monad", see-Note [Fusion for zipN/zipWithN] in GHC/List.hs for more details.--The 'zipWithM'/'zipWithM_' functions are inlined so that the `zipWith` and-`sequenceA` functions with which they are defined have an opportunity to fuse.--Furthermore, 'zipWith3M'/'zipWith4M' and 'zipWith3M_' have been explicitly-rewritten in a non-recursive way similarly to 'zipWithM'/'zipWithM_', and for-more than just uniformity: after [D5241](https://phabricator.haskell.org/D5241)-for issue #14037, all @zipN@/@zipWithN@ functions fuse, meaning-'zipWith3M'/'zipWIth4M' and 'zipWith3M_'@ now behave like 'zipWithM' and-'zipWithM_', respectively, with regards to fusion.--As such, since there are not any differences between 2-ary 'zipWithM'/-'zipWithM_' and their n-ary counterparts below aside from the number of-arguments, the `INLINE` pragma should be replicated in the @zipWithNM@-functions below as well.---}--zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d]-{-# INLINE zipWith3M #-}--- Inline so that fusion with 'zipWith3' and 'sequenceA' has a chance to fire.--- See Note [Inline @zipWithNM@ functions] above.-zipWith3M f xs ys zs = sequenceA (zipWith3 f xs ys zs)--zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m ()-{-# INLINE zipWith3M_ #-}--- Inline so that fusion with 'zipWith4' and 'sequenceA' has a chance to fire.--- See  Note [Inline @zipWithNM@ functions] above.-zipWith3M_ f xs ys zs = sequenceA_ (zipWith3 f xs ys zs)--zipWith4M :: Monad m => (a -> b -> c -> d -> m e)-          -> [a] -> [b] -> [c] -> [d] -> m [e]-{-# INLINE zipWith4M #-}--- Inline so that fusion with 'zipWith5' and 'sequenceA' has a chance to fire.--- See  Note [Inline @zipWithNM@ functions] above.-zipWith4M f xs ys ws zs = sequenceA (zipWith4 f xs ys ws zs)--zipWithAndUnzipM :: Monad m-                 => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])-{-# INLINABLE zipWithAndUnzipM #-}--- See Note [flatten_args performance] in TcFlatten for why this--- pragma is essential.-zipWithAndUnzipM f (x:xs) (y:ys)-  = do { (c, d) <- f x y-       ; (cs, ds) <- zipWithAndUnzipM f xs ys-       ; return (c:cs, d:ds) }-zipWithAndUnzipM _ _ _ = return ([], [])--{---Note [Inline @mapAndUnzipNM@ functions]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--The inline principle is the same as 'mapAndUnzipM' in "Control.Monad".-The 'mapAndUnzipM' function is inlined so that the `unzip` and `traverse`-functions with which it is defined have an opportunity to fuse, see-Note [Inline @unzipN@ functions] in Data/OldList.hs for more details.--Furthermore, the @mapAndUnzipNM@ functions have been explicitly rewritten in a-non-recursive way similarly to 'mapAndUnzipM', and for more than just-uniformity: after [D5249](https://phabricator.haskell.org/D5249) for Trac-ticket #14037, all @unzipN@ functions fuse, meaning 'mapAndUnzip3M',-'mapAndUnzip4M' and 'mapAndUnzip5M' now behave like 'mapAndUnzipM' with regards-to fusion.--As such, since there are not any differences between 2-ary 'mapAndUnzipM' and-its n-ary counterparts below aside from the number of arguments, the `INLINE`-pragma should be replicated in the @mapAndUnzipNM@ functions below as well.---}---- | mapAndUnzipM for triples-mapAndUnzip3M :: Monad m => (a -> m (b,c,d)) -> [a] -> m ([b],[c],[d])-{-# INLINE mapAndUnzip3M #-}--- Inline so that fusion with 'unzip3' and 'traverse' has a chance to fire.--- See Note [Inline @mapAndUnzipNM@ functions] above.-mapAndUnzip3M f xs =  unzip3 <$> traverse f xs--mapAndUnzip4M :: Monad m => (a -> m (b,c,d,e)) -> [a] -> m ([b],[c],[d],[e])-{-# INLINE mapAndUnzip4M #-}--- Inline so that fusion with 'unzip4' and 'traverse' has a chance to fire.--- See Note [Inline @mapAndUnzipNM@ functions] above.-mapAndUnzip4M f xs =  unzip4 <$> traverse f xs--mapAndUnzip5M :: Monad m => (a -> m (b,c,d,e,f)) -> [a] -> m ([b],[c],[d],[e],[f])-{-# INLINE mapAndUnzip5M #-}--- Inline so that fusion with 'unzip5' and 'traverse' has a chance to fire.--- See Note [Inline @mapAndUnzipNM@ functions] above.-mapAndUnzip5M f xs =  unzip5 <$> traverse f xs---- | Monadic version of mapAccumL-mapAccumLM :: Monad m-            => (acc -> x -> m (acc, y)) -- ^ combining function-            -> acc                      -- ^ initial state-            -> [x]                      -- ^ inputs-            -> m (acc, [y])             -- ^ final state, outputs-mapAccumLM _ s []     = return (s, [])-mapAccumLM f s (x:xs) = do-    (s1, x')  <- f s x-    (s2, xs') <- mapAccumLM f s1 xs-    return    (s2, x' : xs')---- | Monadic version of mapSnd-mapSndM :: Monad m => (b -> m c) -> [(a,b)] -> m [(a,c)]-mapSndM _ []         = return []-mapSndM f ((a,b):xs) = do { c <- f b; rs <- mapSndM f xs; return ((a,c):rs) }---- | Monadic version of concatMap-concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]-concatMapM f xs = liftM concat (mapM f xs)---- | Applicative version of mapMaybe-mapMaybeM :: Applicative m => (a -> m (Maybe b)) -> [a] -> m [b]-mapMaybeM f = foldr g (pure [])-  where g a = liftA2 (maybe id (:)) (f a)---- | Monadic version of fmap-fmapMaybeM :: (Monad m) => (a -> m b) -> Maybe a -> m (Maybe b)-fmapMaybeM _ Nothing  = return Nothing-fmapMaybeM f (Just x) = f x >>= (return . Just)---- | Monadic version of fmap-fmapEitherM :: Monad m => (a -> m b) -> (c -> m d) -> Either a c -> m (Either b d)-fmapEitherM fl _ (Left  a) = fl a >>= (return . Left)-fmapEitherM _ fr (Right b) = fr b >>= (return . Right)---- | Monadic version of 'any', aborts the computation at the first @True@ value-anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool-anyM _ []     = return False-anyM f (x:xs) = do b <- f x-                   if b then return True-                        else anyM f xs---- | Monad version of 'all', aborts the computation at the first @False@ value-allM :: Monad m => (a -> m Bool) -> [a] -> m Bool-allM _ []     = return True-allM f (b:bs) = (f b) >>= (\bv -> if bv then allM f bs else return False)---- | Monadic version of or-orM :: Monad m => m Bool -> m Bool -> m Bool-orM m1 m2 = m1 >>= \x -> if x then return True else m2---- | Monadic version of foldl that discards its result-foldlM_ :: (Monad m, Foldable t) => (a -> b -> m a) -> a -> t b -> m ()-foldlM_ = foldM_---- | Monadic version of fmap specialised for Maybe-maybeMapM :: Monad m => (a -> m b) -> (Maybe a -> m (Maybe b))-maybeMapM _ Nothing  = return Nothing-maybeMapM m (Just x) = liftM Just $ m x---- | Monadic version of @when@, taking the condition in the monad-whenM :: Monad m => m Bool -> m () -> m ()-whenM mb thing = do { b <- mb-                    ; when b thing }---- | Monadic version of @unless@, taking the condition in the monad-unlessM :: Monad m => m Bool -> m () -> m ()-unlessM condM acc = do { cond <- condM-                       ; unless cond acc }---- | Like 'filterM', only it reverses the sense of the test.-filterOutM :: (Applicative m) => (a -> m Bool) -> [a] -> m [a]-filterOutM p =-  foldr (\ x -> liftA2 (\ flg -> if flg then id else (x:)) (p x)) (pure [])
− compiler/utils/OrdList.hs 
@@ -1,194 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The AQUA Project, Glasgow University, 1993-1998---This is useful, general stuff for the Native Code Generator.--Provide trees (of instructions), so that lists of instructions-can be appended in linear time.--}-{-# LANGUAGE DeriveFunctor #-}--{-# LANGUAGE BangPatterns #-}--module OrdList (-        OrdList,-        nilOL, isNilOL, unitOL, appOL, consOL, snocOL, concatOL, lastOL,-        headOL,-        mapOL, fromOL, toOL, foldrOL, foldlOL, reverseOL, fromOLReverse,-        strictlyEqOL, strictlyOrdOL-) where--import GhcPrelude-import Data.Foldable--import Outputable--import qualified Data.Semigroup as Semigroup--infixl 5  `appOL`-infixl 5  `snocOL`-infixr 5  `consOL`--data OrdList a-  = None-  | One a-  | Many [a]          -- Invariant: non-empty-  | Cons a (OrdList a)-  | Snoc (OrdList a) a-  | Two (OrdList a) -- Invariant: non-empty-        (OrdList a) -- Invariant: non-empty-  deriving (Functor)--instance Outputable a => Outputable (OrdList a) where-  ppr ol = ppr (fromOL ol)  -- Convert to list and print that--instance Semigroup (OrdList a) where-  (<>) = appOL--instance Monoid (OrdList a) where-  mempty = nilOL-  mappend = (Semigroup.<>)-  mconcat = concatOL--instance Foldable OrdList where-  foldr   = foldrOL-  foldl'  = foldlOL-  toList  = fromOL-  null    = isNilOL-  length  = lengthOL--instance Traversable OrdList where-  traverse f xs = toOL <$> traverse f (fromOL xs)--nilOL    :: OrdList a-isNilOL  :: OrdList a -> Bool--unitOL   :: a           -> OrdList a-snocOL   :: OrdList a   -> a         -> OrdList a-consOL   :: a           -> OrdList a -> OrdList a-appOL    :: OrdList a   -> OrdList a -> OrdList a-concatOL :: [OrdList a] -> OrdList a-headOL   :: OrdList a   -> a-lastOL   :: OrdList a   -> a-lengthOL :: OrdList a   -> Int--nilOL        = None-unitOL as    = One as-snocOL as   b    = Snoc as b-consOL a    bs   = Cons a bs-concatOL aas = foldr appOL None aas--headOL None        = panic "headOL"-headOL (One a)     = a-headOL (Many as)   = head as-headOL (Cons a _)  = a-headOL (Snoc as _) = headOL as-headOL (Two as _)  = headOL as--lastOL None        = panic "lastOL"-lastOL (One a)     = a-lastOL (Many as)   = last as-lastOL (Cons _ as) = lastOL as-lastOL (Snoc _ a)  = a-lastOL (Two _ as)  = lastOL as--lengthOL None        = 0-lengthOL (One _)     = 1-lengthOL (Many as)   = length as-lengthOL (Cons _ as) = 1 + length as-lengthOL (Snoc as _) = 1 + length as-lengthOL (Two as bs) = length as + length bs--isNilOL None = True-isNilOL _    = False--None  `appOL` b     = b-a     `appOL` None  = a-One a `appOL` b     = Cons a b-a     `appOL` One b = Snoc a b-a     `appOL` b     = Two a b--fromOL :: OrdList a -> [a]-fromOL a = go a []-  where go None       acc = acc-        go (One a)    acc = a : acc-        go (Cons a b) acc = a : go b acc-        go (Snoc a b) acc = go a (b:acc)-        go (Two a b)  acc = go a (go b acc)-        go (Many xs)  acc = xs ++ acc--fromOLReverse :: OrdList a -> [a]-fromOLReverse a = go a []-        -- acc is already in reverse order-  where go :: OrdList a -> [a] -> [a]-        go None       acc = acc-        go (One a)    acc = a : acc-        go (Cons a b) acc = go b (a : acc)-        go (Snoc a b) acc = b : go a acc-        go (Two a b)  acc = go b (go a acc)-        go (Many xs)  acc = reverse xs ++ acc--mapOL :: (a -> b) -> OrdList a -> OrdList b-mapOL = fmap--foldrOL :: (a->b->b) -> b -> OrdList a -> b-foldrOL _ z None        = z-foldrOL k z (One x)     = k x z-foldrOL k z (Cons x xs) = k x (foldrOL k z xs)-foldrOL k z (Snoc xs x) = foldrOL k (k x z) xs-foldrOL k z (Two b1 b2) = foldrOL k (foldrOL k z b2) b1-foldrOL k z (Many xs)   = foldr k z xs---- | Strict left fold.-foldlOL :: (b->a->b) -> b -> OrdList a -> b-foldlOL _ z None        = z-foldlOL k z (One x)     = k z x-foldlOL k z (Cons x xs) = let !z' = (k z x) in foldlOL k z' xs-foldlOL k z (Snoc xs x) = let !z' = (foldlOL k z xs) in k z' x-foldlOL k z (Two b1 b2) = let !z' = (foldlOL k z b1) in foldlOL k z' b2-foldlOL k z (Many xs)   = foldl' k z xs--toOL :: [a] -> OrdList a-toOL [] = None-toOL [x] = One x-toOL xs = Many xs--reverseOL :: OrdList a -> OrdList a-reverseOL None = None-reverseOL (One x) = One x-reverseOL (Cons a b) = Snoc (reverseOL b) a-reverseOL (Snoc a b) = Cons b (reverseOL a)-reverseOL (Two a b)  = Two (reverseOL b) (reverseOL a)-reverseOL (Many xs)  = Many (reverse xs)---- | Compare not only the values but also the structure of two lists-strictlyEqOL :: Eq a => OrdList a   -> OrdList a -> Bool-strictlyEqOL None         None       = True-strictlyEqOL (One x)     (One y)     = x == y-strictlyEqOL (Cons a as) (Cons b bs) = a == b && as `strictlyEqOL` bs-strictlyEqOL (Snoc as a) (Snoc bs b) = a == b && as `strictlyEqOL` bs-strictlyEqOL (Two a1 a2) (Two b1 b2) = a1 `strictlyEqOL` b1 && a2 `strictlyEqOL` b2-strictlyEqOL (Many as)   (Many bs)   = as == bs-strictlyEqOL _            _          = False---- | Compare not only the values but also the structure of two lists-strictlyOrdOL :: Ord a => OrdList a   -> OrdList a -> Ordering-strictlyOrdOL None         None       = EQ-strictlyOrdOL None         _          = LT-strictlyOrdOL (One x)     (One y)     = compare x y-strictlyOrdOL (One _)      _          = LT-strictlyOrdOL (Cons a as) (Cons b bs) =-  compare a b `mappend` strictlyOrdOL as bs-strictlyOrdOL (Cons _ _)   _          = LT-strictlyOrdOL (Snoc as a) (Snoc bs b) =-  compare a b `mappend` strictlyOrdOL as bs-strictlyOrdOL (Snoc _ _)   _          = LT-strictlyOrdOL (Two a1 a2) (Two b1 b2) =-  (strictlyOrdOL a1 b1) `mappend` (strictlyOrdOL a2 b2)-strictlyOrdOL (Two _ _)    _          = LT-strictlyOrdOL (Many as)   (Many bs)   = compare as bs-strictlyOrdOL (Many _ )   _           = GT--
− compiler/utils/Outputable.hs 
@@ -1,1304 +0,0 @@-{-# LANGUAGE LambdaCase #-}--{--(c) The University of Glasgow 2006-2012-(c) The GRASP Project, Glasgow University, 1992-1998--}---- | This module defines classes and functions for pretty-printing. It also--- exports a number of helpful debugging and other utilities such as 'trace' and 'panic'.------ The interface to this module is very similar to the standard Hughes-PJ pretty printing--- module, except that it exports a number of additional functions that are rarely used,--- and works over the 'SDoc' type.-module Outputable (-        -- * Type classes-        Outputable(..), OutputableBndr(..),--        -- * Pretty printing combinators-        SDoc, runSDoc, initSDocContext,-        docToSDoc,-        interppSP, interpp'SP,-        pprQuotedList, pprWithCommas, quotedListWithOr, quotedListWithNor,-        pprWithBars,-        empty, isEmpty, nest,-        char,-        text, ftext, ptext, ztext,-        int, intWithCommas, integer, word, float, double, rational, doublePrec,-        parens, cparen, brackets, braces, quotes, quote,-        doubleQuotes, angleBrackets,-        semi, comma, colon, dcolon, space, equals, dot, vbar,-        arrow, larrow, darrow, arrowt, larrowt, arrowtt, larrowtt,-        lparen, rparen, lbrack, rbrack, lbrace, rbrace, underscore,-        blankLine, forAllLit, bullet,-        (<>), (<+>), hcat, hsep,-        ($$), ($+$), vcat,-        sep, cat,-        fsep, fcat,-        hang, hangNotEmpty, punctuate, ppWhen, ppUnless,-        ppWhenOption, ppUnlessOption,-        speakNth, speakN, speakNOf, plural, isOrAre, doOrDoes, itsOrTheir,-        unicodeSyntax,--        coloured, keyword,--        -- * Converting 'SDoc' into strings and outputting it-        printSDoc, printSDocLn, printForUser, printForUserPartWay,-        printForC, bufLeftRenderSDoc,-        pprCode, mkCodeStyle,-        showSDoc, showSDocUnsafe, showSDocOneLine,-        showSDocForUser, showSDocDebug, showSDocDump, showSDocDumpOneLine,-        showSDocUnqual, showPpr,-        renderWithStyle,--        pprInfixVar, pprPrefixVar,-        pprHsChar, pprHsString, pprHsBytes,--        primFloatSuffix, primCharSuffix, primWordSuffix, primDoubleSuffix,-        primInt64Suffix, primWord64Suffix, primIntSuffix,--        pprPrimChar, pprPrimInt, pprPrimWord, pprPrimInt64, pprPrimWord64,--        pprFastFilePath, pprFilePathString,--        -- * Controlling the style in which output is printed-        BindingSite(..),--        PprStyle, CodeStyle(..), PrintUnqualified(..),-        QueryQualifyName, QueryQualifyModule, QueryQualifyPackage,-        reallyAlwaysQualify, reallyAlwaysQualifyNames,-        alwaysQualify, alwaysQualifyNames, alwaysQualifyModules,-        neverQualify, neverQualifyNames, neverQualifyModules,-        alwaysQualifyPackages, neverQualifyPackages,-        QualifyName(..), queryQual,-        sdocWithDynFlags, 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,--        -- * Error handling and debugging utilities-        pprPanic, pprSorry, assertPprPanic, pprPgmError,-        pprTrace, pprTraceDebug, pprTraceWith, pprTraceIt, warnPprTrace,-        pprSTrace, pprTraceException, pprTraceM, pprTraceWithFlags,-        trace, pgmError, panic, sorry, assertPanic,-        pprDebugAndThen, callStackDoc,-    ) where--import GhcPrelude--import {-# SOURCE #-}   GHC.Driver.Session-                           ( DynFlags, hasPprDebug, hasNoDebugOutput-                           , pprUserLength, pprCols-                           , unsafeGlobalDynFlags, initSDocContext-                           )-import {-# SOURCE #-}   GHC.Types.Module( UnitId, Module, ModuleName, moduleName )-import {-# SOURCE #-}   GHC.Types.Name.Occurrence( OccName )--import BufWrite (BufHandle)-import FastString-import qualified Pretty-import Util-import qualified PprColour as Col-import Pretty           ( Doc, Mode(..) )-import Panic-import GHC.Serialized-import GHC.LanguageExtensions (Extension)--import Data.ByteString (ByteString)-import qualified Data.ByteString as BS-import Data.Char-import qualified Data.Map as M-import Data.Int-import qualified Data.IntMap as IM-import Data.Set (Set)-import qualified Data.Set as Set-import Data.String-import Data.Word-import System.IO        ( Handle )-import System.FilePath-import Text.Printf-import Numeric (showFFloat)-import Data.Graph (SCC(..))-import Data.List (intersperse)-import Data.List.NonEmpty (NonEmpty (..))-import qualified Data.List.NonEmpty as NEL--import GHC.Fingerprint-import GHC.Show         ( showMultiLineString )-import GHC.Stack        ( callStack, prettyCallStack )-import Control.Monad.IO.Class-import Exception--{--************************************************************************-*                                                                      *-\subsection{The @PprStyle@ data type}-*                                                                      *-************************************************************************--}--data PprStyle-  = PprUser PrintUnqualified Depth Coloured-                -- Pretty-print in a way that will make sense to the-                -- ordinary user; must be very close to Haskell-                -- syntax, etc.-                -- Assumes printing tidied code: non-system names are-                -- printed without uniques.--  | PprDump PrintUnqualified-                -- For -ddump-foo; less verbose than PprDebug, but more than PprUser-                -- Does not assume tidied code: non-external names-                -- are printed with uniques.--  | PprDebug    -- Full debugging output--  | PprCode CodeStyle-                -- Print code; either C or assembler--data CodeStyle = CStyle         -- The format of labels differs for C and assembler-               | AsmStyle--data Depth = AllTheWay-           | PartWay Int        -- 0 => stop--data Coloured-  = Uncoloured-  | Coloured---- -------------------------------------------------------------------------------- Printing original names---- | When printing code that contains original names, we need to map the--- original names back to something the user understands.  This is the--- purpose of the triple of functions that gets passed around--- when rendering 'SDoc'.-data PrintUnqualified = QueryQualify {-    queryQualifyName    :: QueryQualifyName,-    queryQualifyModule  :: QueryQualifyModule,-    queryQualifyPackage :: QueryQualifyPackage-}---- | Given a `Name`'s `Module` and `OccName`, decide whether and how to qualify--- it.-type QueryQualifyName = Module -> OccName -> QualifyName---- | For a given module, we need to know whether to print it with--- a package name to disambiguate it.-type QueryQualifyModule = Module -> Bool---- | For a given package, we need to know whether to print it with--- the component id to disambiguate it.-type QueryQualifyPackage = UnitId -> Bool---- 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--  | NameQual ModuleName  -- It's in scope qualified as "X.T"--  | NameNotInScope1      -- It's not in scope at all, but M.T is not bound-                         -- in the current scope, so we can refer to it as "M.T"--  | NameNotInScope2      -- It's not in scope at all, and M.T is already bound in-                         -- the current scope, so we must refer to it as "P:M.T"--instance Outputable QualifyName where-  ppr NameUnqual      = text "NameUnqual"-  ppr (NameQual _mod) = text "NameQual"  -- can't print the mod without module loops :(-  ppr NameNotInScope1 = text "NameNotInScope1"-  ppr NameNotInScope2 = text "NameNotInScope2"--reallyAlwaysQualifyNames :: QueryQualifyName-reallyAlwaysQualifyNames _ _ = NameNotInScope2---- | NB: This won't ever show package IDs-alwaysQualifyNames :: QueryQualifyName-alwaysQualifyNames m _ = NameQual (moduleName m)--neverQualifyNames :: QueryQualifyName-neverQualifyNames _ _ = NameUnqual--alwaysQualifyModules :: QueryQualifyModule-alwaysQualifyModules _ = True--neverQualifyModules :: QueryQualifyModule-neverQualifyModules _ = False--alwaysQualifyPackages :: QueryQualifyPackage-alwaysQualifyPackages _ = True--neverQualifyPackages :: QueryQualifyPackage-neverQualifyPackages _ = False--reallyAlwaysQualify, alwaysQualify, neverQualify :: PrintUnqualified-reallyAlwaysQualify-              = QueryQualify reallyAlwaysQualifyNames-                             alwaysQualifyModules-                             alwaysQualifyPackages-alwaysQualify = QueryQualify alwaysQualifyNames-                             alwaysQualifyModules-                             alwaysQualifyPackages-neverQualify  = QueryQualify neverQualifyNames-                             neverQualifyModules-                             neverQualifyPackages--defaultUserStyle :: DynFlags -> PprStyle-defaultUserStyle dflags = mkUserStyle dflags neverQualify AllTheWay--defaultDumpStyle :: DynFlags -> PprStyle- -- Print without qualifiers to reduce verbosity, unless -dppr-debug-defaultDumpStyle dflags-   | hasPprDebug dflags = PprDebug-   | otherwise          = PprDump neverQualify--mkDumpStyle :: DynFlags -> PrintUnqualified -> PprStyle-mkDumpStyle dflags print_unqual-   | hasPprDebug dflags = PprDebug-   | otherwise          = PprDump print_unqual--defaultErrStyle :: DynFlags -> PprStyle--- Default style for error messages, when we don't know PrintUnqualified--- It's a bit of a hack because it doesn't take into account what's in scope--- Only used for desugarer warnings, and typechecker errors in interface sigs--- NB that -dppr-debug will still get into PprDebug style-defaultErrStyle dflags = mkErrStyle dflags neverQualify---- | Style for printing error messages-mkErrStyle :: DynFlags -> PrintUnqualified -> PprStyle-mkErrStyle dflags qual =-   mkUserStyle dflags qual (PartWay (pprUserLength dflags))--cmdlineParserStyle :: DynFlags -> PprStyle-cmdlineParserStyle dflags = mkUserStyle dflags alwaysQualify AllTheWay--mkUserStyle :: DynFlags -> PrintUnqualified -> Depth -> PprStyle-mkUserStyle dflags unqual depth-   | 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-    PprUser q d _ -> PprUser q d c-    _             -> style-  where-    c | col       = Coloured-      | otherwise = Uncoloured--instance Outputable PprStyle where-  ppr (PprUser {})  = text "user-style"-  ppr (PprCode {})  = text "code-style"-  ppr (PprDump {})  = text "dump-style"-  ppr (PprDebug {}) = text "debug-style"--{--Orthogonal to the above printing styles are (possibly) some-command-line flags that affect printing (often carried with the-style).  The most likely ones are variations on how much type info is-shown.--The following test decides whether or not we are actually generating-code (either C or assembly), or generating interface files.--************************************************************************-*                                                                      *-\subsection{The @SDoc@ data type}-*                                                                      *-************************************************************************--}---- | Represents a pretty-printable document.------ To display an 'SDoc', use 'printSDoc', 'printSDocLn', 'bufLeftRenderSDoc',--- or 'renderWithStyle'.  Avoid calling 'runSDoc' directly as it breaks the--- abstraction layer.-newtype SDoc = SDoc { runSDoc :: SDocContext -> Doc }--data SDocContext = SDC-  { 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-  , 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-  fromString = text---- The lazy programmer's friend.-instance Outputable SDoc where-  ppr = id---withPprStyle :: PprStyle -> SDoc -> SDoc-withPprStyle sty d = SDoc $ \ctxt -> runSDoc d ctxt{sdocStyle=sty}--pprDeeper :: SDoc -> SDoc-pprDeeper d = SDoc $ \ctx -> case ctx of-  SDC{sdocStyle=PprUser _ (PartWay 0) _} -> Pretty.text "..."-  SDC{sdocStyle=PprUser q (PartWay n) c} ->-    runSDoc d ctx{sdocStyle = PprUser q (PartWay (n-1)) c}-  _ -> runSDoc d ctx---- | Truncate a list that is longer than the current depth.-pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc-pprDeeperList f ds-  | null ds   = f []-  | otherwise = SDoc work- where-  work ctx@SDC{sdocStyle=PprUser q (PartWay n) c}-   | n==0      = Pretty.text "..."-   | otherwise =-      runSDoc (f (go 0 ds)) ctx{sdocStyle = PprUser q (PartWay (n-1)) c}-   where-     go _ [] = []-     go i (d:ds) | i >= n    = [text "...."]-                 | otherwise = d : go (i+1) ds-  work other_ctx = runSDoc (f ds) other_ctx--pprSetDepth :: Depth -> SDoc -> SDoc-pprSetDepth depth doc = SDoc $ \ctx ->-    case ctx of-        SDC{sdocStyle=PprUser q _ c} ->-            runSDoc doc ctx{sdocStyle = PprUser q depth c}-        _ ->-            runSDoc doc ctx--getPprStyle :: (PprStyle -> SDoc) -> SDoc-getPprStyle df = SDoc $ \ctx -> runSDoc (df (sdocStyle ctx)) ctx--sdocWithDynFlags :: (DynFlags -> SDoc) -> SDoc-sdocWithDynFlags f = SDoc $ \ctx -> runSDoc (f (sdocDynFlags ctx)) 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-qualName _other          mod _   = NameQual (moduleName mod)--qualModule :: PprStyle -> QueryQualifyModule-qualModule (PprUser q _ _)  m = queryQualifyModule q m-qualModule (PprDump q)      m = queryQualifyModule q m-qualModule _other          _m = True--qualPackage :: PprStyle -> QueryQualifyPackage-qualPackage (PprUser q _ _)  m = queryQualifyPackage q m-qualPackage (PprDump q)      m = queryQualifyPackage q m-qualPackage _other          _m = True--queryQual :: PprStyle -> PrintUnqualified-queryQual s = QueryQualify (qualName s)-                           (qualModule s)-                           (qualPackage s)--codeStyle :: PprStyle -> Bool-codeStyle (PprCode _)     = True-codeStyle _               = False--asmStyle :: PprStyle -> Bool-asmStyle (PprCode AsmStyle)  = True-asmStyle _other              = False--dumpStyle :: PprStyle -> Bool-dumpStyle (PprDump {}) = True-dumpStyle _other       = False--debugStyle :: PprStyle -> Bool-debugStyle PprDebug = True-debugStyle _other   = False--userStyle ::  PprStyle -> Bool-userStyle (PprUser {}) = True-userStyle _other       = False--getPprDebug :: (Bool -> SDoc) -> SDoc-getPprDebug d = getPprStyle $ \ sty -> d (debugStyle sty)--ifPprDebug :: SDoc -> SDoc -> SDoc--- ^ Says what to do with and without -dppr-debug-ifPprDebug yes no = getPprDebug $ \ dbg -> if dbg then yes else no--whenPprDebug :: SDoc -> SDoc        -- Empty for non-debug style--- ^ Says what to do with -dppr-debug; without, return empty-whenPprDebug d = ifPprDebug d empty---- | The analog of 'Pretty.printDoc_' for 'SDoc', which tries to make sure the---   terminal doesn't get screwed up by the ANSI color codes if an exception---   is thrown during pretty-printing.-printSDoc :: Mode -> DynFlags -> Handle -> PprStyle -> SDoc -> IO ()-printSDoc mode dflags handle sty doc =-  Pretty.printDoc_ mode cols handle (runSDoc doc ctx)-    `finally`-      Pretty.printDoc_ mode cols handle-        (runSDoc (coloured Col.colReset empty) ctx)-  where-    cols = pprCols dflags-    ctx = initSDocContext dflags sty---- | Like 'printSDoc' but appends an extra newline.-printSDocLn :: Mode -> DynFlags -> Handle -> PprStyle -> SDoc -> IO ()-printSDocLn mode dflags handle sty doc =-  printSDoc mode dflags handle sty (doc $$ text "")--printForUser :: DynFlags -> Handle -> PrintUnqualified -> SDoc -> IO ()-printForUser dflags handle unqual doc-  = printSDocLn PageMode dflags handle-               (mkUserStyle dflags unqual AllTheWay) doc--printForUserPartWay :: DynFlags -> Handle -> Int -> PrintUnqualified -> SDoc-                    -> IO ()-printForUserPartWay dflags handle d unqual doc-  = printSDocLn PageMode dflags handle-                (mkUserStyle dflags unqual (PartWay d)) doc---- | Like 'printSDocLn' but specialized with 'LeftMode' and--- @'PprCode' 'CStyle'@.  This is typically used to output C-- code.-printForC :: DynFlags -> Handle -> SDoc -> IO ()-printForC dflags handle doc =-  printSDocLn LeftMode dflags handle (PprCode CStyle) doc---- | An efficient variant of 'printSDoc' specialized for 'LeftMode' that--- outputs to a 'BufHandle'.-bufLeftRenderSDoc :: DynFlags -> BufHandle -> PprStyle -> SDoc -> IO ()-bufLeftRenderSDoc dflags bufHandle sty doc =-  Pretty.bufLeftRender bufHandle (runSDoc doc (initSDocContext dflags sty))--pprCode :: CodeStyle -> SDoc -> SDoc-pprCode cs d = withPprStyle (PprCode cs) d--mkCodeStyle :: CodeStyle -> PprStyle-mkCodeStyle = PprCode---- Can't make SDoc an instance of Show because SDoc is just a function type--- However, Doc *is* an instance of Show--- showSDoc just blasts it out as a string-showSDoc :: DynFlags -> SDoc -> String-showSDoc dflags sdoc = renderWithStyle (initSDocContext dflags (defaultUserStyle dflags)) sdoc---- showSDocUnsafe is unsafe, because `unsafeGlobalDynFlags` might not be--- initialised yet.-showSDocUnsafe :: SDoc -> String-showSDocUnsafe sdoc = showSDoc unsafeGlobalDynFlags sdoc--showPpr :: Outputable a => DynFlags -> a -> String-showPpr dflags thing = showSDoc dflags (ppr thing)--showSDocUnqual :: DynFlags -> SDoc -> String--- Only used by Haddock-showSDocUnqual dflags sdoc = showSDoc dflags sdoc--showSDocForUser :: DynFlags -> PrintUnqualified -> SDoc -> String--- Allows caller to specify the PrintUnqualified to use-showSDocForUser dflags unqual doc- = renderWithStyle (initSDocContext dflags (mkUserStyle dflags unqual AllTheWay)) doc--showSDocDump :: DynFlags -> SDoc -> String-showSDocDump dflags d = renderWithStyle (initSDocContext dflags (defaultDumpStyle dflags)) d--showSDocDebug :: DynFlags -> SDoc -> String-showSDocDebug dflags d = renderWithStyle (initSDocContext dflags PprDebug) d--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"--- and "foo{uniq strictness}" so we don't want fancy layout anyway.-showSDocOneLine :: DynFlags -> SDoc -> String-showSDocOneLine dflags d- = let s = Pretty.style{ Pretty.mode = OneLineMode,-                         Pretty.lineLength = pprCols dflags } in-   Pretty.renderStyle s $-      runSDoc d (initSDocContext dflags (defaultUserStyle dflags))--showSDocDumpOneLine :: DynFlags -> SDoc -> String-showSDocDumpOneLine dflags d- = let s = Pretty.style{ Pretty.mode = OneLineMode,-                         Pretty.lineLength = irrelevantNCols } in-   Pretty.renderStyle s $-      runSDoc d (initSDocContext dflags (defaultDumpStyle dflags))--irrelevantNCols :: Int--- Used for OneLineMode and LeftMode when number of cols isn't used-irrelevantNCols = 1--isEmpty :: SDocContext -> SDoc -> Bool-isEmpty ctx sdoc = Pretty.isEmpty $ runSDoc sdoc (ctx {sdocStyle = PprDebug})--docToSDoc :: Doc -> SDoc-docToSDoc d = SDoc (\_ -> d)--empty    :: SDoc-char     :: Char       -> SDoc-text     :: String     -> SDoc-ftext    :: FastString -> SDoc-ptext    :: PtrString  -> SDoc-ztext    :: FastZString -> SDoc-int      :: Int        -> SDoc-integer  :: Integer    -> SDoc-word     :: Integer    -> SDoc-float    :: Float      -> SDoc-double   :: Double     -> SDoc-rational :: Rational   -> SDoc--empty       = docToSDoc $ Pretty.empty-char c      = docToSDoc $ Pretty.char c--text s      = docToSDoc $ Pretty.text s-{-# INLINE text #-}   -- Inline so that the RULE Pretty.text will fire--ftext s     = docToSDoc $ Pretty.ftext s-ptext s     = docToSDoc $ Pretty.ptext s-ztext s     = docToSDoc $ Pretty.ztext s-int n       = docToSDoc $ Pretty.int n-integer n   = docToSDoc $ Pretty.integer n-float n     = docToSDoc $ Pretty.float n-double n    = docToSDoc $ Pretty.double n-rational n  = docToSDoc $ Pretty.rational 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.-doublePrec :: Int -> Double -> SDoc-doublePrec p n = text (showFFloat (Just p) n "")--parens, braces, brackets, quotes, quote,-        doubleQuotes, angleBrackets :: SDoc -> SDoc--parens d        = SDoc $ Pretty.parens . runSDoc d-braces d        = SDoc $ Pretty.braces . runSDoc d-brackets d      = SDoc $ Pretty.brackets . runSDoc d-quote d         = SDoc $ Pretty.quote . runSDoc d-doubleQuotes d  = SDoc $ Pretty.doubleQuotes . runSDoc d-angleBrackets d = char '<' <> d <> char '>'--cparen :: Bool -> SDoc -> SDoc-cparen b d = SDoc $ Pretty.maybeParens b . runSDoc d---- '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 = 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-lparen, rparen, lbrack, rbrack, lbrace, rbrace, blankLine :: SDoc--blankLine  = docToSDoc $ Pretty.text ""-dcolon     = unicodeSyntax (char '∷') (docToSDoc $ Pretty.text "::")-arrow      = unicodeSyntax (char '→') (docToSDoc $ Pretty.text "->")-larrow     = unicodeSyntax (char '←') (docToSDoc $ Pretty.text "<-")-darrow     = unicodeSyntax (char '⇒') (docToSDoc $ Pretty.text "=>")-arrowt     = unicodeSyntax (char '⤚') (docToSDoc $ Pretty.text ">-")-larrowt    = unicodeSyntax (char '⤙') (docToSDoc $ Pretty.text "-<")-arrowtt    = unicodeSyntax (char '⤜') (docToSDoc $ Pretty.text ">>-")-larrowtt   = unicodeSyntax (char '⤛') (docToSDoc $ Pretty.text "-<<")-semi       = docToSDoc $ Pretty.semi-comma      = docToSDoc $ Pretty.comma-colon      = docToSDoc $ Pretty.colon-equals     = docToSDoc $ Pretty.equals-space      = docToSDoc $ Pretty.space-underscore = char '_'-dot        = char '.'-vbar       = char '|'-lparen     = docToSDoc $ Pretty.lparen-rparen     = docToSDoc $ Pretty.rparen-lbrack     = docToSDoc $ Pretty.lbrack-rbrack     = docToSDoc $ Pretty.rbrack-lbrace     = docToSDoc $ Pretty.lbrace-rbrace     = docToSDoc $ Pretty.rbrace--forAllLit :: SDoc-forAllLit = unicodeSyntax (char '∀') (text "forall")--bullet :: SDoc-bullet = unicode (char '•') (char '*')--unicodeSyntax :: SDoc -> SDoc -> SDoc-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 = sdocOption sdocCanUseUnicode $ \case-   True  -> unicode-   False -> plain--nest :: Int -> SDoc -> SDoc--- ^ Indent 'SDoc' some specified amount-(<>) :: SDoc -> SDoc -> SDoc--- ^ Join two 'SDoc' together horizontally without a gap-(<+>) :: SDoc -> SDoc -> SDoc--- ^ Join two 'SDoc' together horizontally with a gap between them-($$) :: SDoc -> SDoc -> SDoc--- ^ Join two 'SDoc' together vertically; if there is--- no vertical overlap it "dovetails" the two onto one line-($+$) :: SDoc -> SDoc -> SDoc--- ^ Join two 'SDoc' together vertically--nest n d    = SDoc $ Pretty.nest n . runSDoc d-(<>) d1 d2  = SDoc $ \sty -> (Pretty.<>)  (runSDoc d1 sty) (runSDoc d2 sty)-(<+>) d1 d2 = SDoc $ \sty -> (Pretty.<+>) (runSDoc d1 sty) (runSDoc d2 sty)-($$) d1 d2  = SDoc $ \sty -> (Pretty.$$)  (runSDoc d1 sty) (runSDoc d2 sty)-($+$) d1 d2 = SDoc $ \sty -> (Pretty.$+$) (runSDoc d1 sty) (runSDoc d2 sty)--hcat :: [SDoc] -> SDoc--- ^ Concatenate 'SDoc' horizontally-hsep :: [SDoc] -> SDoc--- ^ Concatenate 'SDoc' horizontally with a space between each one-vcat :: [SDoc] -> SDoc--- ^ Concatenate 'SDoc' vertically with dovetailing-sep :: [SDoc] -> SDoc--- ^ Separate: is either like 'hsep' or like 'vcat', depending on what fits-cat :: [SDoc] -> SDoc--- ^ Catenate: is either like 'hcat' or like 'vcat', depending on what fits-fsep :: [SDoc] -> SDoc--- ^ A paragraph-fill combinator. It's much like sep, only it--- keeps fitting things on one line until it can't fit any more.-fcat :: [SDoc] -> SDoc--- ^ This behaves like 'fsep', but it uses '<>' for horizontal conposition rather than '<+>'---hcat ds = SDoc $ \sty -> Pretty.hcat [runSDoc d sty | d <- ds]-hsep ds = SDoc $ \sty -> Pretty.hsep [runSDoc d sty | d <- ds]-vcat ds = SDoc $ \sty -> Pretty.vcat [runSDoc d sty | d <- ds]-sep ds  = SDoc $ \sty -> Pretty.sep  [runSDoc d sty | d <- ds]-cat ds  = SDoc $ \sty -> Pretty.cat  [runSDoc d sty | d <- ds]-fsep ds = SDoc $ \sty -> Pretty.fsep [runSDoc d sty | d <- ds]-fcat ds = SDoc $ \sty -> Pretty.fcat [runSDoc d sty | d <- ds]--hang :: SDoc  -- ^ The header-      -> Int  -- ^ Amount to indent the hung body-      -> SDoc -- ^ The hung body, indented and placed below the header-      -> SDoc-hang d1 n d2   = SDoc $ \sty -> Pretty.hang (runSDoc d1 sty) n (runSDoc d2 sty)---- | This behaves like 'hang', but does not indent the second document--- when the header is empty.-hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc-hangNotEmpty d1 n d2 =-    SDoc $ \sty -> Pretty.hangNotEmpty (runSDoc d1 sty) n (runSDoc d2 sty)--punctuate :: SDoc   -- ^ The punctuation-          -> [SDoc] -- ^ The list that will have punctuation added between every adjacent pair of elements-          -> [SDoc] -- ^ Punctuated list-punctuate _ []     = []-punctuate p (d:ds) = go d ds-                   where-                     go d [] = [d]-                     go d (e:es) = (d <> p) : go e es--ppWhen, ppUnless :: Bool -> SDoc -> SDoc-ppWhen True  doc = doc-ppWhen False _   = empty--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 = 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--{--************************************************************************-*                                                                      *-\subsection[Outputable-class]{The @Outputable@ class}-*                                                                      *-************************************************************************--}---- | Class designating that some type has an 'SDoc' representation-class Outputable a where-        ppr :: a -> SDoc-        pprPrec :: Rational -> a -> SDoc-                -- 0 binds least tightly-                -- We use Rational because there is always a-                -- Rational between any other two Rationals--        ppr = pprPrec 0-        pprPrec _ = ppr--instance Outputable Char where-    ppr c = text [c]--instance Outputable Bool where-    ppr True  = text "True"-    ppr False = text "False"--instance Outputable Ordering where-    ppr LT = text "LT"-    ppr EQ = text "EQ"-    ppr GT = text "GT"--instance Outputable Int32 where-   ppr n = integer $ fromIntegral n--instance Outputable Int64 where-   ppr n = integer $ fromIntegral n--instance Outputable Int where-    ppr n = int n--instance Outputable Integer where-    ppr n = integer n--instance Outputable Word16 where-    ppr n = integer $ fromIntegral n--instance Outputable Word32 where-    ppr n = integer $ fromIntegral n--instance Outputable Word where-    ppr n = integer $ fromIntegral n--instance Outputable Float where-    ppr f = float f--instance Outputable Double where-    ppr f = double f--instance Outputable () where-    ppr _ = text "()"--instance (Outputable a) => Outputable [a] where-    ppr xs = brackets (fsep (punctuate comma (map ppr xs)))--instance (Outputable a) => Outputable (NonEmpty a) where-    ppr = ppr . NEL.toList--instance (Outputable a) => Outputable (Set a) where-    ppr s = braces (fsep (punctuate comma (map ppr (Set.toList s))))--instance (Outputable a, Outputable b) => Outputable (a, b) where-    ppr (x,y) = parens (sep [ppr x <> comma, ppr y])--instance Outputable a => Outputable (Maybe a) where-    ppr Nothing  = text "Nothing"-    ppr (Just x) = text "Just" <+> ppr x--instance (Outputable a, Outputable b) => Outputable (Either a b) where-    ppr (Left x)  = text "Left"  <+> ppr x-    ppr (Right y) = text "Right" <+> ppr y---- ToDo: may not be used-instance (Outputable a, Outputable b, Outputable c) => Outputable (a, b, c) where-    ppr (x,y,z) =-      parens (sep [ppr x <> comma,-                   ppr y <> comma,-                   ppr z ])--instance (Outputable a, Outputable b, Outputable c, Outputable d) =>-         Outputable (a, b, c, d) where-    ppr (a,b,c,d) =-      parens (sep [ppr a <> comma,-                   ppr b <> comma,-                   ppr c <> comma,-                   ppr d])--instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) =>-         Outputable (a, b, c, d, e) where-    ppr (a,b,c,d,e) =-      parens (sep [ppr a <> comma,-                   ppr b <> comma,-                   ppr c <> comma,-                   ppr d <> comma,-                   ppr e])--instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) =>-         Outputable (a, b, c, d, e, f) where-    ppr (a,b,c,d,e,f) =-      parens (sep [ppr a <> comma,-                   ppr b <> comma,-                   ppr c <> comma,-                   ppr d <> comma,-                   ppr e <> comma,-                   ppr f])--instance (Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) =>-         Outputable (a, b, c, d, e, f, g) where-    ppr (a,b,c,d,e,f,g) =-      parens (sep [ppr a <> comma,-                   ppr b <> comma,-                   ppr c <> comma,-                   ppr d <> comma,-                   ppr e <> comma,-                   ppr f <> comma,-                   ppr g])--instance Outputable FastString where-    ppr fs = ftext fs           -- Prints an unadorned string,-                                -- no double quotes or anything--instance (Outputable key, Outputable elt) => Outputable (M.Map key elt) where-    ppr m = ppr (M.toList m)-instance (Outputable elt) => Outputable (IM.IntMap elt) where-    ppr m = ppr (IM.toList m)--instance Outputable Fingerprint where-    ppr (Fingerprint w1 w2) = text (printf "%016x%016x" w1 w2)--instance Outputable a => Outputable (SCC a) where-   ppr (AcyclicSCC v) = text "NONREC" $$ (nest 3 (ppr v))-   ppr (CyclicSCC vs) = text "REC" $$ (nest 3 (vcat (map ppr vs)))--instance Outputable Serialized where-    ppr (Serialized the_type bytes) = int (length bytes) <+> text "of type" <+> text (show the_type)--instance Outputable Extension where-    ppr = text . show--{--************************************************************************-*                                                                      *-\subsection{The @OutputableBndr@ class}-*                                                                      *-************************************************************************--}---- | '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 GHC.Core.Ppr-data BindingSite-    = LambdaBind  -- ^ The x in   (\x. e)-    | CaseBind    -- ^ The x in   case scrut of x { (y,z) -> ... }-    | CasePatBind -- ^ The y,z in case scrut of x { (y,z) -> ... }-    | LetBind     -- ^ The x in   (let x = rhs in e)---- | When we print a binder, we often want to print its type too.--- The @OutputableBndr@ class encapsulates this idea.-class Outputable a => OutputableBndr a where-   pprBndr :: BindingSite -> a -> SDoc-   pprBndr _b x = ppr x--   pprPrefixOcc, pprInfixOcc :: a -> SDoc-      -- Print an occurrence of the name, suitable either in the-      -- prefix position of an application, thus   (f a b) or  ((+) x)-      -- or infix position,                 thus   (a `f` b) or  (x + y)--   bndrIsJoin_maybe :: a -> Maybe Int-   bndrIsJoin_maybe _ = Nothing-      -- When pretty-printing we sometimes want to find-      -- whether the binder is a join point.  You might think-      -- we could have a function of type (a->Var), but Var-      -- isn't available yet, alas--{--************************************************************************-*                                                                      *-\subsection{Random printing helpers}-*                                                                      *-************************************************************************--}---- We have 31-bit Chars and will simply use Show instances of Char and String.---- | Special combinator for showing character literals.-pprHsChar :: Char -> SDoc-pprHsChar c | c > '\x10ffff' = char '\\' <> text (show (fromIntegral (ord c) :: Word32))-            | otherwise      = text (show c)---- | Special combinator for showing string literals.-pprHsString :: FastString -> SDoc-pprHsString fs = vcat (map text (showMultiLineString (unpackFS fs)))---- | Special combinator for showing bytestring literals.-pprHsBytes :: ByteString -> SDoc-pprHsBytes bs = let escaped = concatMap escape $ BS.unpack bs-                in vcat (map text (showMultiLineString escaped)) <> char '#'-    where escape :: Word8 -> String-          escape w = let c = chr (fromIntegral w)-                     in if isAscii c-                        then [c]-                        else '\\' : show w---- Postfix modifiers for unboxed literals.--- See Note [Printing of literals in Core] in `basicTypes/Literal.hs`.-primCharSuffix, primFloatSuffix, primIntSuffix :: SDoc-primDoubleSuffix, primWordSuffix, primInt64Suffix, primWord64Suffix :: SDoc-primCharSuffix   = char '#'-primFloatSuffix  = char '#'-primIntSuffix    = char '#'-primDoubleSuffix = text "##"-primWordSuffix   = text "##"-primInt64Suffix  = text "L#"-primWord64Suffix = text "L##"---- | Special combinator for showing unboxed literals.-pprPrimChar :: Char -> SDoc-pprPrimInt, pprPrimWord, pprPrimInt64, pprPrimWord64 :: Integer -> SDoc-pprPrimChar c   = pprHsChar c <> primCharSuffix-pprPrimInt i    = integer i   <> primIntSuffix-pprPrimWord w   = word    w   <> primWordSuffix-pprPrimInt64 i  = integer i   <> primInt64Suffix-pprPrimWord64 w = word    w   <> primWord64Suffix-------------------------- Put a name in parens if it's an operator-pprPrefixVar :: Bool -> SDoc -> SDoc-pprPrefixVar is_operator pp_v-  | is_operator = parens pp_v-  | otherwise   = pp_v---- Put a name in backquotes if it's not an operator-pprInfixVar :: Bool -> SDoc -> SDoc-pprInfixVar is_operator pp_v-  | is_operator = pp_v-  | otherwise   = char '`' <> pp_v <> char '`'------------------------pprFastFilePath :: FastString -> SDoc-pprFastFilePath path = text $ normalise $ unpackFS path---- | Normalise, escape and render a string representing a path------ e.g. "c:\\whatever"-pprFilePathString :: FilePath -> SDoc-pprFilePathString path = doubleQuotes $ text (escape (normalise path))-   where-      escape []        = []-      escape ('\\':xs) = '\\':'\\':escape xs-      escape (x:xs)    = x:escape xs--{--************************************************************************-*                                                                      *-\subsection{Other helper functions}-*                                                                      *-************************************************************************--}--pprWithCommas :: (a -> SDoc) -- ^ The pretty printing function to use-              -> [a]         -- ^ The things to be pretty printed-              -> SDoc        -- ^ 'SDoc' where the things have been pretty printed,-                             -- comma-separated and finally packed into a paragraph.-pprWithCommas pp xs = fsep (punctuate comma (map pp xs))--pprWithBars :: (a -> SDoc) -- ^ The pretty printing function to use-            -> [a]         -- ^ The things to be pretty printed-            -> SDoc        -- ^ 'SDoc' where the things have been pretty printed,-                           -- bar-separated and finally packed into a paragraph.-pprWithBars pp xs = fsep (intersperse vbar (map pp xs))---- | Returns the separated concatenation of the pretty printed things.-interppSP  :: Outputable a => [a] -> SDoc-interppSP  xs = sep (map ppr xs)---- | Returns the comma-separated concatenation of the pretty printed things.-interpp'SP :: Outputable a => [a] -> SDoc-interpp'SP xs = sep (punctuate comma (map ppr xs))---- | Returns the comma-separated concatenation of the quoted pretty printed things.------ > [x,y,z]  ==>  `x', `y', `z'-pprQuotedList :: Outputable a => [a] -> SDoc-pprQuotedList = quotedList . map ppr--quotedList :: [SDoc] -> SDoc-quotedList xs = fsep (punctuate comma (map quotes xs))--quotedListWithOr :: [SDoc] -> SDoc--- [x,y,z]  ==>  `x', `y' or `z'-quotedListWithOr xs@(_:_:_) = quotedList (init xs) <+> text "or" <+> quotes (last xs)-quotedListWithOr xs = quotedList xs--quotedListWithNor :: [SDoc] -> SDoc--- [x,y,z]  ==>  `x', `y' nor `z'-quotedListWithNor xs@(_:_:_) = quotedList (init xs) <+> text "nor" <+> quotes (last xs)-quotedListWithNor xs = quotedList xs--{--************************************************************************-*                                                                      *-\subsection{Printing numbers verbally}-*                                                                      *-************************************************************************--}--intWithCommas :: Integral a => a -> SDoc--- Prints a big integer with commas, eg 345,821-intWithCommas n-  | n < 0     = char '-' <> intWithCommas (-n)-  | q == 0    = int (fromIntegral r)-  | otherwise = intWithCommas q <> comma <> zeroes <> int (fromIntegral r)-  where-    (q,r) = n `quotRem` 1000-    zeroes | r >= 100  = empty-           | r >= 10   = char '0'-           | otherwise = text "00"---- | Converts an integer to a verbal index:------ > speakNth 1 = text "first"--- > speakNth 5 = text "fifth"--- > speakNth 21 = text "21st"-speakNth :: Int -> SDoc-speakNth 1 = text "first"-speakNth 2 = text "second"-speakNth 3 = text "third"-speakNth 4 = text "fourth"-speakNth 5 = text "fifth"-speakNth 6 = text "sixth"-speakNth n = hcat [ int n, text suffix ]-  where-    suffix | n <= 20       = "th"       -- 11,12,13 are non-std-           | last_dig == 1 = "st"-           | last_dig == 2 = "nd"-           | last_dig == 3 = "rd"-           | otherwise     = "th"--    last_dig = n `rem` 10---- | Converts an integer to a verbal multiplicity:------ > speakN 0 = text "none"--- > speakN 5 = text "five"--- > speakN 10 = text "10"-speakN :: Int -> SDoc-speakN 0 = text "none"  -- E.g.  "he has none"-speakN 1 = text "one"   -- E.g.  "he has one"-speakN 2 = text "two"-speakN 3 = text "three"-speakN 4 = text "four"-speakN 5 = text "five"-speakN 6 = text "six"-speakN n = int n---- | Converts an integer and object description to a statement about the--- multiplicity of those objects:------ > speakNOf 0 (text "melon") = text "no melons"--- > speakNOf 1 (text "melon") = text "one melon"--- > speakNOf 3 (text "melon") = text "three melons"-speakNOf :: Int -> SDoc -> SDoc-speakNOf 0 d = text "no" <+> d <> char 's'-speakNOf 1 d = text "one" <+> d                 -- E.g. "one argument"-speakNOf n d = speakN n <+> d <> char 's'               -- E.g. "three arguments"---- | Determines the pluralisation suffix appropriate for the length of a list:------ > plural [] = char 's'--- > plural ["Hello"] = empty--- > plural ["Hello", "World"] = char 's'-plural :: [a] -> SDoc-plural [_] = empty  -- a bit frightening, but there you are-plural _   = char 's'---- | Determines the form of to be appropriate for the length of a list:------ > isOrAre [] = text "are"--- > isOrAre ["Hello"] = text "is"--- > isOrAre ["Hello", "World"] = text "are"-isOrAre :: [a] -> SDoc-isOrAre [_] = text "is"-isOrAre _   = text "are"---- | Determines the form of to do appropriate for the length of a list:------ > doOrDoes [] = text "do"--- > doOrDoes ["Hello"] = text "does"--- > doOrDoes ["Hello", "World"] = text "do"-doOrDoes :: [a] -> SDoc-doOrDoes [_] = text "does"-doOrDoes _   = text "do"---- | Determines the form of possessive appropriate for the length of a list:------ > itsOrTheir [x]   = text "its"--- > itsOrTheir [x,y] = text "their"--- > itsOrTheir []    = text "their"  -- probably avoid this-itsOrTheir :: [a] -> SDoc-itsOrTheir [_] = text "its"-itsOrTheir _   = text "their"--{--************************************************************************-*                                                                      *-\subsection{Error handling}-*                                                                      *-************************************************************************--}--callStackDoc :: HasCallStack => SDoc-callStackDoc =-    hang (text "Call stack:")-       4 (vcat $ map text $ lines (prettyCallStack callStack))--pprPanic :: HasCallStack => String -> SDoc -> a--- ^ Throw an exception saying "bug in GHC"-pprPanic s doc = panicDoc s (doc $$ callStackDoc)--pprSorry :: String -> SDoc -> a--- ^ Throw an exception saying "this isn't finished yet"-pprSorry    = sorryDoc---pprPgmError :: String -> SDoc -> a--- ^ Throw an exception saying "bug in pgm being compiled" (used for unusual program errors)-pprPgmError = pgmErrorDoc--pprTraceDebug :: String -> SDoc -> a -> a-pprTraceDebug str doc x-   | debugIsOn && hasPprDebug unsafeGlobalDynFlags = pprTrace str doc x-   | otherwise                                     = x---- | If debug output is on, show some 'SDoc' on the screen-pprTrace :: String -> SDoc -> a -> a-pprTrace str doc x = pprTraceWithFlags unsafeGlobalDynFlags str doc x---- | If debug output is on, show some 'SDoc' on the screen-pprTraceWithFlags :: DynFlags -> String -> SDoc -> a -> a-pprTraceWithFlags dflags str doc x-  | hasNoDebugOutput dflags = x-  | otherwise               = pprDebugAndThen dflags trace (text str) doc x--pprTraceM :: Applicative f => String -> SDoc -> f ()-pprTraceM str doc = pprTrace str doc (pure ())---- | @pprTraceWith desc f x@ is equivalent to @pprTrace desc (f x) x@.--- This allows you to print details from the returned value as well as from--- ambient variables.-pprTraceWith :: String -> (a -> SDoc) -> a -> a-pprTraceWith desc f x = pprTrace desc (f x) x---- | @pprTraceIt desc x@ is equivalent to @pprTrace desc (ppr x) x@-pprTraceIt :: Outputable a => String -> a -> a-pprTraceIt desc x = pprTraceWith desc ppr x---- | @pprTraceException desc x action@ runs action, printing a message--- if it throws an exception.-pprTraceException :: ExceptionMonad m => String -> SDoc -> m a -> m a-pprTraceException heading doc =-    handleGhcException $ \exc -> liftIO $ do-        putStrLn $ showSDocDump unsafeGlobalDynFlags (sep [text heading, nest 2 doc])-        throwGhcExceptionIO exc---- | If debug output is on, show some 'SDoc' on the screen along--- with a call stack when available.-pprSTrace :: HasCallStack => SDoc -> a -> a-pprSTrace doc = pprTrace "" (doc $$ callStackDoc)--warnPprTrace :: HasCallStack => Bool -> String -> Int -> SDoc -> a -> a--- ^ Just warn about an assertion failure, recording the given file and line number.--- Should typically be accessed with the WARN macros-warnPprTrace _     _     _     _    x | not debugIsOn     = x-warnPprTrace _     _file _line _msg x-   | hasNoDebugOutput unsafeGlobalDynFlags = x-warnPprTrace False _file _line _msg x = x-warnPprTrace True   file  line  msg x-  = pprDebugAndThen unsafeGlobalDynFlags trace heading-                    (msg $$ callStackDoc )-                    x-  where-    heading = hsep [text "WARNING: file", text file <> comma, text "line", int line]---- | Panic with an assertion failure, recording the given file and--- line number. Should typically be accessed with the ASSERT family of macros-assertPprPanic :: HasCallStack => String -> Int -> SDoc -> a-assertPprPanic _file _line msg-  = pprPanic "ASSERT failed!" msg--pprDebugAndThen :: DynFlags -> (String -> a) -> SDoc -> SDoc -> a-pprDebugAndThen dflags cont heading pretty_msg- = cont (showSDocDump dflags doc)- where-     doc = sep [heading, nest 2 pretty_msg]
− compiler/utils/Outputable.hs-boot 
@@ -1,14 +0,0 @@-module Outputable where--import GhcPrelude-import GHC.Stack( HasCallStack )--data SDoc-data PprStyle-data SDocContext--showSDocUnsafe :: SDoc -> String--warnPprTrace :: HasCallStack => Bool -> String -> Int -> SDoc -> a -> a--text :: String -> SDoc
− compiler/utils/Pair.hs 
@@ -1,60 +0,0 @@-{--A simple homogeneous pair type with useful Functor, Applicative, and-Traversable instances.--}--{-# LANGUAGE CPP #-}-{-# LANGUAGE DeriveFunctor #-}--module Pair ( Pair(..), unPair, toPair, swap, pLiftFst, pLiftSnd ) where--#include "HsVersions.h"--import GhcPrelude--import Outputable-import qualified Data.Semigroup as Semi--data Pair a = Pair { pFst :: a, pSnd :: a }-  deriving (Functor)--- Note that Pair is a *unary* type constructor--- whereas (,) is binary---- The important thing about Pair is that it has a *homogeneous*--- Functor instance, so you can easily apply the same function--- to both components--instance Applicative Pair where-  pure x = Pair x x-  (Pair f g) <*> (Pair x y) = Pair (f x) (g y)--instance Foldable Pair where-  foldMap f (Pair x y) = f x `mappend` f y--instance Traversable Pair where-  traverse f (Pair x y) = Pair <$> f x <*> f y--instance Semi.Semigroup a => Semi.Semigroup (Pair a) where-  Pair a1 b1 <> Pair a2 b2 =  Pair (a1 Semi.<> a2) (b1 Semi.<> b2)--instance (Semi.Semigroup a, Monoid a) => Monoid (Pair a) where-  mempty = Pair mempty mempty-  mappend = (Semi.<>)--instance Outputable a => Outputable (Pair a) where-  ppr (Pair a b) = ppr a <+> char '~' <+> ppr b--unPair :: Pair a -> (a,a)-unPair (Pair x y) = (x,y)--toPair :: (a,a) -> Pair a-toPair (x,y) = Pair x y--swap :: Pair a -> Pair a-swap (Pair x y) = Pair y x--pLiftFst :: (a -> a) -> Pair a -> Pair a-pLiftFst f (Pair a b) = Pair (f a) b--pLiftSnd :: (a -> a) -> Pair a -> Pair a-pLiftSnd f (Pair a b) = Pair a (f b)
− compiler/utils/Panic.hs 
@@ -1,259 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP Project, Glasgow University, 1992-2000--Defines basic functions for printing error messages.--It's hard to put these functions anywhere else without causing-some unnecessary loops in the module dependency graph.--}--{-# LANGUAGE CPP, ScopedTypeVariables, LambdaCase #-}--module Panic (-     GhcException(..), showGhcException,-     throwGhcException, throwGhcExceptionIO,-     handleGhcException,-     PlainPanic.progName,-     pgmError,--     panic, sorry, assertPanic, trace,-     panicDoc, sorryDoc, pgmErrorDoc,--     cmdLineError, cmdLineErrorIO,--     Exception.Exception(..), showException, safeShowException,-     try, tryMost, throwTo,--     withSignalHandlers,-) where--import GhcPrelude--import {-# SOURCE #-} Outputable (SDoc, showSDocUnsafe)-import PlainPanic--import Exception--import Control.Monad.IO.Class-import Control.Concurrent-import Data.Typeable      ( cast )-import Debug.Trace        ( trace )-import System.IO.Unsafe--#if !defined(mingw32_HOST_OS)-import System.Posix.Signals as S-#endif--#if defined(mingw32_HOST_OS)-import GHC.ConsoleHandler as S-#endif--import System.Mem.Weak  ( deRefWeak )---- | GHC's own exception type---   error messages all take the form:------  @---      <location>: <error>---  @------   If the location is on the command line, or in GHC itself, then---   <location>="ghc".  All of the error types below correspond to---   a <location> of "ghc", except for ProgramError (where the string is---  assumed to contain a location already, so we don't print one).--data GhcException-  -- | Some other fatal signal (SIGHUP,SIGTERM)-  = Signal Int--  -- | Prints the short usage msg after the error-  | UsageError   String--  -- | A problem with the command line arguments, but don't print usage.-  | CmdLineError String--  -- | The 'impossible' happened.-  | Panic        String-  | PprPanic     String SDoc--  -- | The user tickled something that's known not to work yet,-  --   but we're not counting it as a bug.-  | Sorry        String-  | PprSorry     String SDoc--  -- | An installation problem.-  | InstallationError String--  -- | An error in the user's code, probably.-  | ProgramError    String-  | PprProgramError String SDoc--instance Exception GhcException where-  fromException (SomeException e)-    | Just ge <- cast e = Just ge-    | Just pge <- cast e = Just $-        case pge of-          PlainSignal n -> Signal n-          PlainUsageError str -> UsageError str-          PlainCmdLineError str -> CmdLineError str-          PlainPanic str -> Panic str-          PlainSorry str -> Sorry str-          PlainInstallationError str -> InstallationError str-          PlainProgramError str -> ProgramError str-    | otherwise = Nothing--instance Show GhcException where-  showsPrec _ e@(ProgramError _) = showGhcException e-  showsPrec _ e@(CmdLineError _) = showString "<command line>: " . showGhcException e-  showsPrec _ e = showString progName . showString ": " . showGhcException e---- | Show an exception as a string.-showException :: Exception e => e -> String-showException = show---- | Show an exception which can possibly throw other exceptions.--- Used when displaying exception thrown within TH code.-safeShowException :: Exception e => e -> IO String-safeShowException e = do-    -- ensure the whole error message is evaluated inside try-    r <- try (return $! forceList (showException e))-    case r of-        Right msg -> return msg-        Left e' -> safeShowException (e' :: SomeException)-    where-        forceList [] = []-        forceList xs@(x : xt) = x `seq` forceList xt `seq` xs---- | Append a description of the given exception to this string.------ Note that this uses 'DynFlags.unsafeGlobalDynFlags', which may have some--- uninitialized fields if invoked before 'GHC.initGhcMonad' has been called.--- If the error message to be printed includes a pretty-printer document--- which forces one of these fields this call may bottom.-showGhcException :: GhcException -> ShowS-showGhcException = showPlainGhcException . \case-  Signal n -> PlainSignal n-  UsageError str -> PlainUsageError str-  CmdLineError str -> PlainCmdLineError str-  Panic str -> PlainPanic str-  Sorry str -> PlainSorry str-  InstallationError str -> PlainInstallationError str-  ProgramError str -> PlainProgramError str--  PprPanic str sdoc -> PlainPanic $-      concat [str, "\n\n", showSDocUnsafe sdoc]-  PprSorry str sdoc -> PlainProgramError $-      concat [str, "\n\n", showSDocUnsafe sdoc]-  PprProgramError str sdoc -> PlainProgramError $-      concat [str, "\n\n", showSDocUnsafe sdoc]--throwGhcException :: GhcException -> a-throwGhcException = Exception.throw--throwGhcExceptionIO :: GhcException -> IO a-throwGhcExceptionIO = Exception.throwIO--handleGhcException :: ExceptionMonad m => (GhcException -> m a) -> m a -> m a-handleGhcException = ghandle--panicDoc, sorryDoc, pgmErrorDoc :: String -> SDoc -> a-panicDoc    x doc = throwGhcException (PprPanic        x doc)-sorryDoc    x doc = throwGhcException (PprSorry        x doc)-pgmErrorDoc x doc = throwGhcException (PprProgramError x doc)---- | Like try, but pass through UserInterrupt and Panic exceptions.---   Used when we want soft failures when reading interface files, for example.---   TODO: I'm not entirely sure if this is catching what we really want to catch-tryMost :: IO a -> IO (Either SomeException a)-tryMost action = do r <- try action-                    case r of-                        Left se ->-                            case fromException se of-                                -- Some GhcException's we rethrow,-                                Just (Signal _)  -> throwIO se-                                Just (Panic _)   -> throwIO se-                                -- others we return-                                Just _           -> return (Left se)-                                Nothing ->-                                    case fromException se of-                                        -- All IOExceptions are returned-                                        Just (_ :: IOException) ->-                                            return (Left se)-                                        -- Anything else is rethrown-                                        Nothing -> throwIO se-                        Right v -> return (Right v)---- | We use reference counting for signal handlers-{-# NOINLINE signalHandlersRefCount #-}-#if !defined(mingw32_HOST_OS)-signalHandlersRefCount :: MVar (Word, Maybe (S.Handler,S.Handler-                                            ,S.Handler,S.Handler))-#else-signalHandlersRefCount :: MVar (Word, Maybe S.Handler)-#endif-signalHandlersRefCount = unsafePerformIO $ newMVar (0,Nothing)----- | Temporarily install standard signal handlers for catching ^C, which just--- throw an exception in the current thread.-withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a-withSignalHandlers act = do-  main_thread <- liftIO myThreadId-  wtid <- liftIO (mkWeakThreadId main_thread)--  let-      interrupt = do-        r <- deRefWeak wtid-        case r of-          Nothing -> return ()-          Just t  -> throwTo t UserInterrupt--#if !defined(mingw32_HOST_OS)-  let installHandlers = do-        let installHandler' a b = installHandler a b Nothing-        hdlQUIT <- installHandler' sigQUIT  (Catch interrupt)-        hdlINT  <- installHandler' sigINT   (Catch interrupt)-        -- see #3656; in the future we should install these automatically for-        -- all Haskell programs in the same way that we install a ^C handler.-        let fatal_signal n = throwTo main_thread (Signal (fromIntegral n))-        hdlHUP  <- installHandler' sigHUP   (Catch (fatal_signal sigHUP))-        hdlTERM <- installHandler' sigTERM  (Catch (fatal_signal sigTERM))-        return (hdlQUIT,hdlINT,hdlHUP,hdlTERM)--  let uninstallHandlers (hdlQUIT,hdlINT,hdlHUP,hdlTERM) = do-        _ <- installHandler sigQUIT  hdlQUIT Nothing-        _ <- installHandler sigINT   hdlINT  Nothing-        _ <- installHandler sigHUP   hdlHUP  Nothing-        _ <- installHandler sigTERM  hdlTERM Nothing-        return ()-#else-  -- GHC 6.3+ has support for console events on Windows-  -- NOTE: running GHCi under a bash shell for some reason requires-  -- you to press Ctrl-Break rather than Ctrl-C to provoke-  -- an interrupt.  Ctrl-C is getting blocked somewhere, I don't know-  -- why --SDM 17/12/2004-  let sig_handler ControlC = interrupt-      sig_handler Break    = interrupt-      sig_handler _        = return ()--  let installHandlers   = installHandler (Catch sig_handler)-  let uninstallHandlers = installHandler -- directly install the old handler-#endif--  -- install signal handlers if necessary-  let mayInstallHandlers = liftIO $ modifyMVar_ signalHandlersRefCount $ \case-        (0,Nothing)     -> do-          hdls <- installHandlers-          return (1,Just hdls)-        (c,oldHandlers) -> return (c+1,oldHandlers)--  -- uninstall handlers if necessary-  let mayUninstallHandlers = liftIO $ modifyMVar_ signalHandlersRefCount $ \case-        (1,Just hdls)   -> do-          _ <- uninstallHandlers hdls-          return (0,Nothing)-        (c,oldHandlers) -> return (c-1,oldHandlers)--  mayInstallHandlers-  act `gfinally` mayUninstallHandlers
− compiler/utils/PlainPanic.hs 
@@ -1,138 +0,0 @@-{-# LANGUAGE CPP, ScopedTypeVariables, LambdaCase #-}---- | Defines a simple exception type and utilities to throw it. The--- 'PlainGhcException' type is a subset of the 'Panic.GhcException'--- type.  It omits the exception constructors that involve--- pretty-printing via 'Outputable.SDoc'.------ There are two reasons for this:------ 1. To avoid import cycles / use of boot files. "Outputable" has--- many transitive dependencies. To throw exceptions from these--- modules, the functions here can be used without introducing import--- cycles.------ 2. To reduce the number of modules that need to be compiled to--- object code when loading GHC into GHCi. See #13101-module PlainPanic-  ( PlainGhcException(..)-  , showPlainGhcException--  , panic, sorry, pgmError-  , cmdLineError, cmdLineErrorIO-  , assertPanic--  , progName-  ) where--#include "HsVersions.h"--import Config-import Exception-import GHC.Stack-import GhcPrelude-import System.Environment-import System.IO.Unsafe---- | This type is very similar to 'Panic.GhcException', but it omits--- the constructors that involve pretty-printing via--- 'Outputable.SDoc'.  Due to the implementation of 'fromException'--- for 'Panic.GhcException', this type can be caught as a--- 'Panic.GhcException'.------ Note that this should only be used for throwing exceptions, not for--- catching, as 'Panic.GhcException' will not be converted to this--- type when catching.-data PlainGhcException-  -- | Some other fatal signal (SIGHUP,SIGTERM)-  = PlainSignal Int--  -- | Prints the short usage msg after the error-  | PlainUsageError        String--  -- | A problem with the command line arguments, but don't print usage.-  | PlainCmdLineError      String--  -- | The 'impossible' happened.-  | PlainPanic             String--  -- | The user tickled something that's known not to work yet,-  --   but we're not counting it as a bug.-  | PlainSorry             String--  -- | An installation problem.-  | PlainInstallationError String--  -- | An error in the user's code, probably.-  | PlainProgramError      String--instance Exception PlainGhcException--instance Show PlainGhcException where-  showsPrec _ e@(PlainProgramError _) = showPlainGhcException e-  showsPrec _ e@(PlainCmdLineError _) = showString "<command line>: " . showPlainGhcException e-  showsPrec _ e = showString progName . showString ": " . showPlainGhcException e---- | The name of this GHC.-progName :: String-progName = unsafePerformIO (getProgName)-{-# NOINLINE progName #-}---- | Short usage information to display when we are given the wrong cmd line arguments.-short_usage :: String-short_usage = "Usage: For basic information, try the `--help' option."---- | Append a description of the given exception to this string.-showPlainGhcException :: PlainGhcException -> ShowS-showPlainGhcException =-  \case-    PlainSignal n -> showString "signal: " . shows n-    PlainUsageError str -> showString str . showChar '\n' . showString short_usage-    PlainCmdLineError str -> showString str-    PlainPanic s -> panicMsg (showString s)-    PlainSorry s -> sorryMsg (showString s)-    PlainInstallationError str -> showString str-    PlainProgramError str -> showString str-  where-    sorryMsg :: ShowS -> ShowS-    sorryMsg s =-        showString "sorry! (unimplemented feature or known bug)\n"-      . showString ("  (GHC version " ++ cProjectVersion ++ ":\n\t")-      . s . showString "\n"--    panicMsg :: ShowS -> ShowS-    panicMsg s =-        showString "panic! (the 'impossible' happened)\n"-      . showString ("  (GHC version " ++ cProjectVersion ++ ":\n\t")-      . s . showString "\n\n"-      . showString "Please report this as a GHC bug:  https://www.haskell.org/ghc/reportabug\n"--throwPlainGhcException :: PlainGhcException -> a-throwPlainGhcException = Exception.throw---- | Panics and asserts.-panic, sorry, pgmError :: String -> a-panic    x = unsafeDupablePerformIO $ do-   stack <- ccsToStrings =<< getCurrentCCS x-   if null stack-      then throwPlainGhcException (PlainPanic x)-      else throwPlainGhcException (PlainPanic (x ++ '\n' : renderStack stack))--sorry    x = throwPlainGhcException (PlainSorry x)-pgmError x = throwPlainGhcException (PlainProgramError x)--cmdLineError :: String -> a-cmdLineError = unsafeDupablePerformIO . cmdLineErrorIO--cmdLineErrorIO :: String -> IO a-cmdLineErrorIO x = do-  stack <- ccsToStrings =<< getCurrentCCS x-  if null stack-    then throwPlainGhcException (PlainCmdLineError x)-    else throwPlainGhcException (PlainCmdLineError (x ++ '\n' : renderStack stack))---- | Throw a failed assertion exception for a given filename and line number.-assertPanic :: String -> Int -> a-assertPanic file line =-  Exception.throw (Exception.AssertionFailed-           ("ASSERT failed! file " ++ file ++ ", line " ++ show line))
− compiler/utils/PprColour.hs 
@@ -1,101 +0,0 @@-module PprColour where-import GhcPrelude--import Data.Maybe (fromMaybe)-import Util (OverridingBool(..), split)-import Data.Semigroup as Semi---- | A colour\/style for use with 'coloured'.-newtype PprColour = PprColour { renderColour :: String }--instance Semi.Semigroup PprColour where-  PprColour s1 <> PprColour s2 = PprColour (s1 <> s2)---- | Allow colours to be combined (e.g. bold + red);---   In case of conflict, right side takes precedence.-instance Monoid PprColour where-  mempty = PprColour mempty-  mappend = (<>)--renderColourAfresh :: PprColour -> String-renderColourAfresh c = renderColour (colReset `mappend` c)--colCustom :: String -> PprColour-colCustom "" = mempty-colCustom s  = PprColour ("\27[" ++ s ++ "m")--colReset :: PprColour-colReset = colCustom "0"--colBold :: PprColour-colBold = colCustom ";1"--colBlackFg :: PprColour-colBlackFg = colCustom "30"--colRedFg :: PprColour-colRedFg = colCustom "31"--colGreenFg :: PprColour-colGreenFg = colCustom "32"--colYellowFg :: PprColour-colYellowFg = colCustom "33"--colBlueFg :: PprColour-colBlueFg = colCustom "34"--colMagentaFg :: PprColour-colMagentaFg = colCustom "35"--colCyanFg :: PprColour-colCyanFg = colCustom "36"--colWhiteFg :: PprColour-colWhiteFg = colCustom "37"--data Scheme =-  Scheme-  { sHeader  :: PprColour-  , sMessage :: PprColour-  , sWarning :: PprColour-  , sError   :: PprColour-  , sFatal   :: PprColour-  , sMargin  :: PprColour-  }--defaultScheme :: Scheme-defaultScheme =-  Scheme-  { sHeader  = mempty-  , sMessage = colBold-  , sWarning = colBold `mappend` colMagentaFg-  , sError   = colBold `mappend` colRedFg-  , sFatal   = colBold `mappend` colRedFg-  , sMargin  = colBold `mappend` colBlueFg-  }---- | Parse the colour scheme from a string (presumably from the @GHC_COLORS@--- environment variable).-parseScheme :: String -> (OverridingBool, Scheme) -> (OverridingBool, Scheme)-parseScheme "always" (_, cs) = (Always, cs)-parseScheme "auto"   (_, cs) = (Auto,   cs)-parseScheme "never"  (_, cs) = (Never,  cs)-parseScheme input    (b, cs) =-  ( b-  , Scheme-    { sHeader  = fromMaybe (sHeader cs)  (lookup "header" table)-    , sMessage = fromMaybe (sMessage cs) (lookup "message" table)-    , sWarning = fromMaybe (sWarning cs) (lookup "warning" table)-    , sError   = fromMaybe (sError cs)   (lookup "error"   table)-    , sFatal   = fromMaybe (sFatal cs)   (lookup "fatal"   table)-    , sMargin  = fromMaybe (sMargin cs)  (lookup "margin"  table)-    }-  )-  where-    table = do-      w <- split ':' input-      let (k, v') = break (== '=') w-      case v' of-        '=' : v -> return (k, colCustom v)-        _ -> []
− compiler/utils/Pretty.hs 
@@ -1,1105 +0,0 @@-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE MagicHash #-}---------------------------------------------------------------------------------- |--- Module      :  Pretty--- Copyright   :  (c) The University of Glasgow 2001--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  David Terei <code@davidterei.com>--- Stability   :  stable--- Portability :  portable------ John Hughes's and Simon Peyton Jones's Pretty Printer Combinators------ Based on /The Design of a Pretty-printing Library/--- in Advanced Functional Programming,--- Johan Jeuring and Erik Meijer (eds), LNCS 925--- <http://www.cs.chalmers.se/~rjmh/Papers/pretty.ps>-----------------------------------------------------------------------------------{--Note [Differences between libraries/pretty and compiler/utils/Pretty.hs]--For historical reasons, there are two different copies of `Pretty` in the GHC-source tree:- * `libraries/pretty` is a submodule containing-   https://github.com/haskell/pretty. This is the `pretty` library as released-   on hackage. It is used by several other libraries in the GHC source tree-   (e.g. template-haskell and Cabal).- * `compiler/utils/Pretty.hs` (this module). It is used by GHC only.--There is an ongoing effort in https://github.com/haskell/pretty/issues/1 and-https://gitlab.haskell.org/ghc/ghc/issues/10735 to try to get rid of GHC's copy-of Pretty.--Currently, GHC's copy of Pretty resembles pretty-1.1.2.0, with the following-major differences:- * GHC's copy uses `Faststring` for performance reasons.- * GHC's copy has received a backported bugfix for #12227, which was-   released as pretty-1.1.3.4 ("Remove harmful $! forcing in beside",-   https://github.com/haskell/pretty/pull/35).--Other differences are minor. Both copies define some extra functions and-instances not defined in the other copy. To see all differences, do this in a-ghc git tree:--    $ cd libraries/pretty-    $ git checkout v1.1.2.0-    $ cd --    $ vimdiff compiler/utils/Pretty.hs \-              libraries/pretty/src/Text/PrettyPrint/HughesPJ.hs--For parity with `pretty-1.1.2.1`, the following two `pretty` commits would-have to be backported:-  * "Resolve foldr-strictness stack overflow bug"-    (307b8173f41cd776eae8f547267df6d72bff2d68)-  * "Special-case reduce for horiz/vert"-    (c57c7a9dfc49617ba8d6e4fcdb019a3f29f1044c)-This has not been done sofar, because these commits seem to cause more-allocation in the compiler (see thomie's comments in-https://github.com/haskell/pretty/pull/9).--}--module Pretty (--        -- * The document type-        Doc, TextDetails(..),--        -- * Constructing documents--        -- ** Converting values into documents-        char, text, ftext, ptext, ztext, sizedText, zeroWidthText,-        int, integer, float, double, rational, hex,--        -- ** Simple derived documents-        semi, comma, colon, space, equals,-        lparen, rparen, lbrack, rbrack, lbrace, rbrace,--        -- ** Wrapping documents in delimiters-        parens, brackets, braces, quotes, quote, doubleQuotes,-        maybeParens,--        -- ** Combining documents-        empty,-        (<>), (<+>), hcat, hsep,-        ($$), ($+$), vcat,-        sep, cat,-        fsep, fcat,-        nest,-        hang, hangNotEmpty, punctuate,--        -- * Predicates on documents-        isEmpty,--        -- * Rendering documents--        -- ** Rendering with a particular style-        Style(..),-        style,-        renderStyle,-        Mode(..),--        -- ** General rendering-        fullRender, txtPrinter,--        -- ** GHC-specific rendering-        printDoc, printDoc_,-        bufLeftRender -- performance hack--  ) where--import GhcPrelude hiding (error)--import BufWrite-import FastString-import PlainPanic-import System.IO-import Numeric (showHex)----for a RULES-import GHC.Base ( unpackCString#, unpackNBytes#, Int(..) )-import GHC.Ptr  ( Ptr(..) )---- ------------------------------------------------------------------------------ The Doc calculus--{--Laws for $$-~~~~~~~~~~~-<a1>    (x $$ y) $$ z   = x $$ (y $$ z)-<a2>    empty $$ x      = x-<a3>    x $$ empty      = x--        ...ditto $+$...--Laws for <>-~~~~~~~~~~~-<b1>    (x <> y) <> z   = x <> (y <> z)-<b2>    empty <> x      = empty-<b3>    x <> empty      = x--        ...ditto <+>...--Laws for text-~~~~~~~~~~~~~-<t1>    text s <> text t        = text (s++t)-<t2>    text "" <> x            = x, if x non-empty--** because of law n6, t2 only holds if x doesn't-** start with `nest'.---Laws for nest-~~~~~~~~~~~~~-<n1>    nest 0 x                = x-<n2>    nest k (nest k' x)      = nest (k+k') x-<n3>    nest k (x <> y)         = nest k x <> nest k y-<n4>    nest k (x $$ y)         = nest k x $$ nest k y-<n5>    nest k empty            = empty-<n6>    x <> nest k y           = x <> y, if x non-empty--** Note the side condition on <n6>!  It is this that-** makes it OK for empty to be a left unit for <>.--Miscellaneous-~~~~~~~~~~~~~-<m1>    (text s <> x) $$ y = text s <> ((text "" <> x) $$-                                         nest (-length s) y)--<m2>    (x $$ y) <> z = x $$ (y <> z)-        if y non-empty---Laws for list versions-~~~~~~~~~~~~~~~~~~~~~~-<l1>    sep (ps++[empty]++qs)   = sep (ps ++ qs)-        ...ditto hsep, hcat, vcat, fill...--<l2>    nest k (sep ps) = sep (map (nest k) ps)-        ...ditto hsep, hcat, vcat, fill...--Laws for oneLiner-~~~~~~~~~~~~~~~~~-<o1>    oneLiner (nest k p) = nest k (oneLiner p)-<o2>    oneLiner (x <> y)   = oneLiner x <> oneLiner y--You might think that the following version of <m1> would-be neater:--<3 NO>  (text s <> x) $$ y = text s <> ((empty <> x)) $$-                                         nest (-length s) y)--But it doesn't work, for if x=empty, we would have--        text s $$ y = text s <> (empty $$ nest (-length s) y)-                    = text s <> nest (-length s) y--}---- ------------------------------------------------------------------------------ Operator fixity--infixl 6 <>-infixl 6 <+>-infixl 5 $$, $+$----- ------------------------------------------------------------------------------ The Doc data type---- | The abstract type of documents.--- A Doc represents a *set* of layouts. A Doc with--- no occurrences of Union or NoDoc represents just one layout.-data Doc-  = Empty                                            -- empty-  | NilAbove Doc                                     -- text "" $$ x-  | TextBeside !TextDetails {-# UNPACK #-} !Int Doc  -- text s <> x-  | Nest {-# UNPACK #-} !Int Doc                     -- nest k x-  | Union Doc Doc                                    -- ul `union` ur-  | NoDoc                                            -- The empty set of documents-  | Beside Doc Bool Doc                              -- True <=> space between-  | Above Doc Bool Doc                               -- True <=> never overlap--{--Here are the invariants:--1) The argument of NilAbove is never Empty. Therefore-   a NilAbove occupies at least two lines.--2) The argument of @TextBeside@ is never @Nest@.--3) The layouts of the two arguments of @Union@ both flatten to the same-   string.--4) The arguments of @Union@ are either @TextBeside@, or @NilAbove@.--5) A @NoDoc@ may only appear on the first line of the left argument of an-   union. Therefore, the right argument of an union can never be equivalent-   to the empty set (@NoDoc@).--6) An empty document is always represented by @Empty@.  It can't be-   hidden inside a @Nest@, or a @Union@ of two @Empty@s.--7) The first line of every layout in the left argument of @Union@ is-   longer than the first line of any layout in the right argument.-   (1) ensures that the left argument has a first line.  In view of-   (3), this invariant means that the right argument must have at-   least two lines.--Notice the difference between-   * NoDoc (no documents)-   * Empty (one empty document; no height and no width)-   * text "" (a document containing the empty string;-              one line high, but has no width)--}----- | RDoc is a "reduced GDoc", guaranteed not to have a top-level Above or Beside.-type RDoc = Doc---- | The TextDetails data type------ A TextDetails represents a fragment of text that will be--- output at some point.-data TextDetails = Chr  {-# UNPACK #-} !Char -- ^ A single Char fragment-                 | Str  String -- ^ A whole String fragment-                 | PStr FastString                      -- a hashed string-                 | ZStr FastZString                     -- a z-encoded string-                 | LStr {-# UNPACK #-} !PtrString-                   -- a '\0'-terminated array of bytes-                 | RStr {-# UNPACK #-} !Int {-# UNPACK #-} !Char-                   -- a repeated character (e.g., ' ')--instance Show Doc where-  showsPrec _ doc cont = fullRender (mode style) (lineLength style)-                                    (ribbonsPerLine style)-                                    txtPrinter cont doc----- ------------------------------------------------------------------------------ Values and Predicates on GDocs and TextDetails---- | A document of height and width 1, containing a literal character.-char :: Char -> Doc-char c = textBeside_ (Chr c) 1 Empty---- | A document of height 1 containing a literal string.--- 'text' satisfies the following laws:------ * @'text' s '<>' 'text' t = 'text' (s'++'t)@------ * @'text' \"\" '<>' x = x@, if @x@ non-empty------ The side condition on the last law is necessary because @'text' \"\"@--- has height 1, while 'empty' has no height.-text :: String -> Doc-text s = textBeside_ (Str s) (length s) Empty-{-# NOINLINE [0] text #-}   -- Give the RULE a chance to fire-                            -- It must wait till after phase 1 when-                            -- the unpackCString first is manifested---- RULE that turns (text "abc") into (ptext (A# "abc"#)) to avoid the--- intermediate packing/unpacking of the string.-{-# RULES "text/str"-    forall a. text (unpackCString# a)  = ptext (mkPtrString# a)-  #-}-{-# RULES "text/unpackNBytes#"-    forall p n. text (unpackNBytes# p n) = ptext (PtrString (Ptr p) (I# n))-  #-}--ftext :: FastString -> Doc-ftext s = textBeside_ (PStr s) (lengthFS s) Empty--ptext :: PtrString -> Doc-ptext s = textBeside_ (LStr s) (lengthPS s) Empty--ztext :: FastZString -> Doc-ztext s = textBeside_ (ZStr s) (lengthFZS s) Empty---- | Some text with any width. (@text s = sizedText (length s) s@)-sizedText :: Int -> String -> Doc-sizedText l s = textBeside_ (Str s) l Empty---- | Some text, but without any width. Use for non-printing text--- such as a HTML or Latex tags-zeroWidthText :: String -> Doc-zeroWidthText = sizedText 0---- | The empty document, with no height and no width.--- 'empty' is the identity for '<>', '<+>', '$$' and '$+$', and anywhere--- in the argument list for 'sep', 'hcat', 'hsep', 'vcat', 'fcat' etc.-empty :: Doc-empty = Empty---- | Returns 'True' if the document is empty-isEmpty :: Doc -> Bool-isEmpty Empty = True-isEmpty _     = False--{--Q: What is the reason for negative indentation (i.e. argument to indent-   is < 0) ?--A:-This indicates an error in the library client's code.-If we compose a <> b, and the first line of b is more indented than some-other lines of b, the law <n6> (<> eats nests) may cause the pretty-printer to produce an invalid layout:--doc       |0123345--------------------d1        |a...|-d2        |...b|-          |c...|--d1<>d2    |ab..|-         c|....|--Consider a <> b, let `s' be the length of the last line of `a', `k' the-indentation of the first line of b, and `k0' the indentation of the-left-most line b_i of b.--The produced layout will have negative indentation if `k - k0 > s', as-the first line of b will be put on the (s+1)th column, effectively-translating b horizontally by (k-s). Now if the i^th line of b has an-indentation k0 < (k-s), it is translated out-of-page, causing-`negative indentation'.--}---semi   :: Doc -- ^ A ';' character-comma  :: Doc -- ^ A ',' character-colon  :: Doc -- ^ A ':' character-space  :: Doc -- ^ A space character-equals :: Doc -- ^ A '=' character-lparen :: Doc -- ^ A '(' character-rparen :: Doc -- ^ A ')' character-lbrack :: Doc -- ^ A '[' character-rbrack :: Doc -- ^ A ']' character-lbrace :: Doc -- ^ A '{' character-rbrace :: Doc -- ^ A '}' character-semi   = char ';'-comma  = char ','-colon  = char ':'-space  = char ' '-equals = char '='-lparen = char '('-rparen = char ')'-lbrack = char '['-rbrack = char ']'-lbrace = char '{'-rbrace = char '}'--spaceText, nlText :: TextDetails-spaceText = Chr ' '-nlText    = Chr '\n'--int      :: Int      -> Doc -- ^ @int n = text (show n)@-integer  :: Integer  -> Doc -- ^ @integer n = text (show n)@-float    :: Float    -> Doc -- ^ @float n = text (show n)@-double   :: Double   -> Doc -- ^ @double n = text (show n)@-rational :: Rational -> Doc -- ^ @rational n = text (show n)@-hex      :: Integer  -> Doc -- ^ See Note [Print Hexadecimal Literals]-int      n = text (show n)-integer  n = text (show n)-float    n = text (show n)-double   n = text (show n)-rational n = text (show n)-hex      n = text ('0' : 'x' : padded)-    where-    str = showHex n ""-    strLen = max 1 (length str)-    len = 2 ^ (ceiling (logBase 2 (fromIntegral strLen :: Double)) :: Int)-    padded = replicate (len - strLen) '0' ++ str--parens       :: Doc -> Doc -- ^ Wrap document in @(...)@-brackets     :: Doc -> Doc -- ^ Wrap document in @[...]@-braces       :: Doc -> Doc -- ^ Wrap document in @{...}@-quotes       :: Doc -> Doc -- ^ Wrap document in @\'...\'@-quote        :: Doc -> Doc-doubleQuotes :: Doc -> Doc -- ^ Wrap document in @\"...\"@-quotes p       = char '`' <> p <> char '\''-quote p        = char '\'' <> p-doubleQuotes p = char '"' <> p <> char '"'-parens p       = char '(' <> p <> char ')'-brackets p     = char '[' <> p <> char ']'-braces p       = char '{' <> p <> char '}'--{--Note [Print Hexadecimal Literals]--Relevant discussions:- * Phabricator: https://phabricator.haskell.org/D4465- * GHC Trac: https://gitlab.haskell.org/ghc/ghc/issues/14872--There is a flag `-dword-hex-literals` that causes literals of-type `Word#` or `Word64#` to be displayed in hexadecimal instead-of decimal when dumping GHC core. It also affects the presentation-of these in GHC's error messages. Additionally, the hexadecimal-encoding of these numbers is zero-padded so that its length is-a power of two. As an example of what this does,-consider the following haskell file `Literals.hs`:--    module Literals where--    alpha :: Int-    alpha = 100 + 200--    beta :: Word -> Word-    beta x = x + div maxBound 255 + div 0xFFFFFFFF 255 + 0x0202--We get the following dumped core when we compile on a 64-bit-machine with ghc -O2 -fforce-recomp -ddump-simpl -dsuppress-all--dhex-word-literals literals.hs:--    ==================== Tidy Core ====================--    ... omitted for brevity ...--    -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}-    alpha-    alpha = I# 300#--    -- RHS size: {terms: 12, types: 3, coercions: 0, joins: 0/0}-    beta-    beta-      = \ x_aYE ->-          case x_aYE of { W# x#_a1v0 ->-          W#-            (plusWord#-               (plusWord# (plusWord# x#_a1v0 0x0101010101010101##) 0x01010101##)-               0x0202##)-          }--Notice that the word literals are in hexadecimals and that they have-been padded with zeroes so that their lengths are 16, 8, and 4, respectively.---}---- | Apply 'parens' to 'Doc' if boolean is true.-maybeParens :: Bool -> Doc -> Doc-maybeParens False = id-maybeParens True = parens---- ------------------------------------------------------------------------------ Structural operations on GDocs---- | Perform some simplification of a built up @GDoc@.-reduceDoc :: Doc -> RDoc-reduceDoc (Beside p g q) = p `seq` g `seq` (beside p g $! reduceDoc q)-reduceDoc (Above  p g q) = p `seq` g `seq` (above  p g $! reduceDoc q)-reduceDoc p              = p---- | List version of '<>'.-hcat :: [Doc] -> Doc-hcat = reduceAB . foldr (beside_' False) empty---- | List version of '<+>'.-hsep :: [Doc] -> Doc-hsep = reduceAB . foldr (beside_' True)  empty---- | List version of '$$'.-vcat :: [Doc] -> Doc-vcat = reduceAB . foldr (above_' False) empty---- | Nest (or indent) a document by a given number of positions--- (which may also be negative).  'nest' satisfies the laws:------ * @'nest' 0 x = x@------ * @'nest' k ('nest' k' x) = 'nest' (k+k') x@------ * @'nest' k (x '<>' y) = 'nest' k z '<>' 'nest' k y@------ * @'nest' k (x '$$' y) = 'nest' k x '$$' 'nest' k y@------ * @'nest' k 'empty' = 'empty'@------ * @x '<>' 'nest' k y = x '<>' y@, if @x@ non-empty------ The side condition on the last law is needed because--- 'empty' is a left identity for '<>'.-nest :: Int -> Doc -> Doc-nest k p = mkNest k (reduceDoc p)---- | @hang d1 n d2 = sep [d1, nest n d2]@-hang :: Doc -> Int -> Doc -> Doc-hang d1 n d2 = sep [d1, nest n d2]---- | Apply 'hang' to the arguments if the first 'Doc' is not empty.-hangNotEmpty :: Doc -> Int -> Doc -> Doc-hangNotEmpty d1 n d2 = if isEmpty d1-                       then d2-                       else hang d1 n d2---- | @punctuate p [d1, ... dn] = [d1 \<> p, d2 \<> p, ... dn-1 \<> p, dn]@-punctuate :: Doc -> [Doc] -> [Doc]-punctuate _ []     = []-punctuate p (x:xs) = go x xs-                   where go y []     = [y]-                         go y (z:zs) = (y <> p) : go z zs---- mkNest checks for Nest's invariant that it doesn't have an Empty inside it-mkNest :: Int -> Doc -> Doc-mkNest k _ | k `seq` False = undefined-mkNest k (Nest k1 p)       = mkNest (k + k1) p-mkNest _ NoDoc             = NoDoc-mkNest _ Empty             = Empty-mkNest 0 p                 = p-mkNest k p                 = nest_ k p---- mkUnion checks for an empty document-mkUnion :: Doc -> Doc -> Doc-mkUnion Empty _ = Empty-mkUnion p q     = p `union_` q--beside_' :: Bool -> Doc -> Doc -> Doc-beside_' _ p Empty = p-beside_' g p q     = Beside p g q--above_' :: Bool -> Doc -> Doc -> Doc-above_' _ p Empty = p-above_' g p q     = Above p g q--reduceAB :: Doc -> Doc-reduceAB (Above  Empty _ q) = q-reduceAB (Beside Empty _ q) = q-reduceAB doc                = doc--nilAbove_ :: RDoc -> RDoc-nilAbove_ = NilAbove---- Arg of a TextBeside is always an RDoc-textBeside_ :: TextDetails -> Int -> RDoc -> RDoc-textBeside_ = TextBeside--nest_ :: Int -> RDoc -> RDoc-nest_ = Nest--union_ :: RDoc -> RDoc -> RDoc-union_ = Union----- ------------------------------------------------------------------------------ Vertical composition @$$@---- | Above, except that if the last line of the first argument stops--- at least one position before the first line of the second begins,--- these two lines are overlapped.  For example:------ >    text "hi" $$ nest 5 (text "there")------ lays out as------ >    hi   there------ rather than------ >    hi--- >         there------ '$$' is associative, with identity 'empty', and also satisfies------ * @(x '$$' y) '<>' z = x '$$' (y '<>' z)@, if @y@ non-empty.----($$) :: Doc -> Doc -> Doc-p $$  q = above_ p False q---- | Above, with no overlapping.--- '$+$' is associative, with identity 'empty'.-($+$) :: Doc -> Doc -> Doc-p $+$ q = above_ p True q--above_ :: Doc -> Bool -> Doc -> Doc-above_ p _ Empty = p-above_ Empty _ q = q-above_ p g q     = Above p g q--above :: Doc -> Bool -> RDoc -> RDoc-above (Above p g1 q1)  g2 q2 = above p g1 (above q1 g2 q2)-above p@(Beside{})     g  q  = aboveNest (reduceDoc p) g 0 (reduceDoc q)-above p g q                  = aboveNest p             g 0 (reduceDoc q)---- Specification: aboveNest p g k q = p $g$ (nest k q)-aboveNest :: RDoc -> Bool -> Int -> RDoc -> RDoc-aboveNest _                   _ k _ | k `seq` False = undefined-aboveNest NoDoc               _ _ _ = NoDoc-aboveNest (p1 `Union` p2)     g k q = aboveNest p1 g k q `union_`-                                      aboveNest p2 g k q--aboveNest Empty               _ k q = mkNest k q-aboveNest (Nest k1 p)         g k q = nest_ k1 (aboveNest p g (k - k1) q)-                                  -- p can't be Empty, so no need for mkNest--aboveNest (NilAbove p)        g k q = nilAbove_ (aboveNest p g k q)-aboveNest (TextBeside s sl p) g k q = textBeside_ s sl rest-                                    where-                                      !k1  = k - sl-                                      rest = case p of-                                                Empty -> nilAboveNest g k1 q-                                                _     -> aboveNest  p g k1 q-aboveNest (Above {})          _ _ _ = error "aboveNest Above"-aboveNest (Beside {})         _ _ _ = error "aboveNest Beside"---- Specification: text s <> nilaboveNest g k q---              = text s <> (text "" $g$ nest k q)-nilAboveNest :: Bool -> Int -> RDoc -> RDoc-nilAboveNest _ k _           | k `seq` False = undefined-nilAboveNest _ _ Empty       = Empty-                               -- Here's why the "text s <>" is in the spec!-nilAboveNest g k (Nest k1 q) = nilAboveNest g (k + k1) q-nilAboveNest g k q           | not g && k > 0      -- No newline if no overlap-                             = textBeside_ (RStr k ' ') k q-                             | otherwise           -- Put them really above-                             = nilAbove_ (mkNest k q)----- ------------------------------------------------------------------------------ Horizontal composition @<>@---- We intentionally avoid Data.Monoid.(<>) here due to interactions of--- Data.Monoid.(<>) and (<+>).  See--- http://www.haskell.org/pipermail/libraries/2011-November/017066.html---- | Beside.--- '<>' is associative, with identity 'empty'.-(<>) :: Doc -> Doc -> Doc-p <>  q = beside_ p False q---- | Beside, separated by space, unless one of the arguments is 'empty'.--- '<+>' is associative, with identity 'empty'.-(<+>) :: Doc -> Doc -> Doc-p <+> q = beside_ p True  q--beside_ :: Doc -> Bool -> Doc -> Doc-beside_ p _ Empty = p-beside_ Empty _ q = q-beside_ p g q     = Beside p g q---- Specification: beside g p q = p <g> q-beside :: Doc -> Bool -> RDoc -> RDoc-beside NoDoc               _ _   = NoDoc-beside (p1 `Union` p2)     g q   = beside p1 g q `union_` beside p2 g q-beside Empty               _ q   = q-beside (Nest k p)          g q   = nest_ k $! beside p g q-beside p@(Beside p1 g1 q1) g2 q2-         | g1 == g2              = beside p1 g1 $! beside q1 g2 q2-         | otherwise             = beside (reduceDoc p) g2 q2-beside p@(Above{})         g q   = let !d = reduceDoc p in beside d g q-beside (NilAbove p)        g q   = nilAbove_ $! beside p g q-beside (TextBeside s sl p) g q   = textBeside_ s sl rest-                               where-                                  rest = case p of-                                           Empty -> nilBeside g q-                                           _     -> beside p g q---- Specification: text "" <> nilBeside g p---              = text "" <g> p-nilBeside :: Bool -> RDoc -> RDoc-nilBeside _ Empty         = Empty -- Hence the text "" in the spec-nilBeside g (Nest _ p)    = nilBeside g p-nilBeside g p | g         = textBeside_ spaceText 1 p-              | otherwise = p----- ------------------------------------------------------------------------------ Separate, @sep@---- Specification: sep ps  = oneLiner (hsep ps)---                         `union`---                          vcat ps---- | Either 'hsep' or 'vcat'.-sep  :: [Doc] -> Doc-sep = sepX True   -- Separate with spaces---- | Either 'hcat' or 'vcat'.-cat :: [Doc] -> Doc-cat = sepX False  -- Don't--sepX :: Bool -> [Doc] -> Doc-sepX _ []     = empty-sepX x (p:ps) = sep1 x (reduceDoc p) 0 ps----- Specification: sep1 g k ys = sep (x : map (nest k) ys)---                            = oneLiner (x <g> nest k (hsep ys))---                              `union` x $$ nest k (vcat ys)-sep1 :: Bool -> RDoc -> Int -> [Doc] -> RDoc-sep1 _ _                   k _  | k `seq` False = undefined-sep1 _ NoDoc               _ _  = NoDoc-sep1 g (p `Union` q)       k ys = sep1 g p k ys `union_`-                                  aboveNest q False k (reduceDoc (vcat ys))--sep1 g Empty               k ys = mkNest k (sepX g ys)-sep1 g (Nest n p)          k ys = nest_ n (sep1 g p (k - n) ys)--sep1 _ (NilAbove p)        k ys = nilAbove_-                                  (aboveNest p False k (reduceDoc (vcat ys)))-sep1 g (TextBeside s sl p) k ys = textBeside_ s sl (sepNB g p (k - sl) ys)-sep1 _ (Above {})          _ _  = error "sep1 Above"-sep1 _ (Beside {})         _ _  = error "sep1 Beside"---- Specification: sepNB p k ys = sep1 (text "" <> p) k ys--- Called when we have already found some text in the first item--- We have to eat up nests-sepNB :: Bool -> Doc -> Int -> [Doc] -> Doc-sepNB g (Nest _ p) k ys-  = sepNB g p k ys -- Never triggered, because of invariant (2)-sepNB g Empty k ys-  = oneLiner (nilBeside g (reduceDoc rest)) `mkUnion`-    -- XXX: TODO: PRETTY: Used to use True here (but GHC used False...)-    nilAboveNest False k (reduceDoc (vcat ys))-  where-    rest | g         = hsep ys-         | otherwise = hcat ys-sepNB g p k ys-  = sep1 g p k ys----- ------------------------------------------------------------------------------ @fill@---- | \"Paragraph fill\" version of 'cat'.-fcat :: [Doc] -> Doc-fcat = fill False---- | \"Paragraph fill\" version of 'sep'.-fsep :: [Doc] -> Doc-fsep = fill True---- Specification:------ fill g docs = fillIndent 0 docs------ fillIndent k [] = []--- fillIndent k [p] = p--- fillIndent k (p1:p2:ps) =---    oneLiner p1 <g> fillIndent (k + length p1 + g ? 1 : 0)---                               (remove_nests (oneLiner p2) : ps)---     `Union`---    (p1 $*$ nest (-k) (fillIndent 0 ps))------ $*$ is defined for layouts (not Docs) as--- layout1 $*$ layout2 | hasMoreThanOneLine layout1 = layout1 $$ layout2---                     | otherwise                  = layout1 $+$ layout2--fill :: Bool -> [Doc] -> RDoc-fill _ []     = empty-fill g (p:ps) = fill1 g (reduceDoc p) 0 ps--fill1 :: Bool -> RDoc -> Int -> [Doc] -> Doc-fill1 _ _                   k _  | k `seq` False = undefined-fill1 _ NoDoc               _ _  = NoDoc-fill1 g (p `Union` q)       k ys = fill1 g p k ys `union_`-                                   aboveNest q False k (fill g ys)-fill1 g Empty               k ys = mkNest k (fill g ys)-fill1 g (Nest n p)          k ys = nest_ n (fill1 g p (k - n) ys)-fill1 g (NilAbove p)        k ys = nilAbove_ (aboveNest p False k (fill g ys))-fill1 g (TextBeside s sl p) k ys = textBeside_ s sl (fillNB g p (k - sl) ys)-fill1 _ (Above {})          _ _  = error "fill1 Above"-fill1 _ (Beside {})         _ _  = error "fill1 Beside"--fillNB :: Bool -> Doc -> Int -> [Doc] -> Doc-fillNB _ _           k _  | k `seq` False = undefined-fillNB g (Nest _ p)  k ys   = fillNB g p k ys-                              -- Never triggered, because of invariant (2)-fillNB _ Empty _ []         = Empty-fillNB g Empty k (Empty:ys) = fillNB g Empty k ys-fillNB g Empty k (y:ys)     = fillNBE g k y ys-fillNB g p k ys             = fill1 g p k ys---fillNBE :: Bool -> Int -> Doc -> [Doc] -> Doc-fillNBE g k y ys-  = nilBeside g (fill1 g ((elideNest . oneLiner . reduceDoc) y) k' ys)-    -- XXX: TODO: PRETTY: Used to use True here (but GHC used False...)-    `mkUnion` nilAboveNest False k (fill g (y:ys))-  where k' = if g then k - 1 else k--elideNest :: Doc -> Doc-elideNest (Nest _ d) = d-elideNest d          = d---- ------------------------------------------------------------------------------ Selecting the best layout--best :: Int   -- Line length-     -> Int   -- Ribbon length-     -> RDoc-     -> RDoc  -- No unions in here!-best w0 r = get w0-  where-    get :: Int          -- (Remaining) width of line-        -> Doc -> Doc-    get w _ | w == 0 && False = undefined-    get _ Empty               = Empty-    get _ NoDoc               = NoDoc-    get w (NilAbove p)        = nilAbove_ (get w p)-    get w (TextBeside s sl p) = textBeside_ s sl (get1 w sl p)-    get w (Nest k p)          = nest_ k (get (w - k) p)-    get w (p `Union` q)       = nicest w r (get w p) (get w q)-    get _ (Above {})          = error "best get Above"-    get _ (Beside {})         = error "best get Beside"--    get1 :: Int         -- (Remaining) width of line-         -> Int         -- Amount of first line already eaten up-         -> Doc         -- This is an argument to TextBeside => eat Nests-         -> Doc         -- No unions in here!--    get1 w _ _ | w == 0 && False  = undefined-    get1 _ _  Empty               = Empty-    get1 _ _  NoDoc               = NoDoc-    get1 w sl (NilAbove p)        = nilAbove_ (get (w - sl) p)-    get1 w sl (TextBeside t tl p) = textBeside_ t tl (get1 w (sl + tl) p)-    get1 w sl (Nest _ p)          = get1 w sl p-    get1 w sl (p `Union` q)       = nicest1 w r sl (get1 w sl p)-                                                   (get1 w sl q)-    get1 _ _  (Above {})          = error "best get1 Above"-    get1 _ _  (Beside {})         = error "best get1 Beside"--nicest :: Int -> Int -> Doc -> Doc -> Doc-nicest !w !r = nicest1 w r 0--nicest1 :: Int -> Int -> Int -> Doc -> Doc -> Doc-nicest1 !w !r !sl p q | fits ((w `min` r) - sl) p = p-                      | otherwise                 = q--fits :: Int  -- Space available-     -> Doc-     -> Bool -- True if *first line* of Doc fits in space available-fits n _ | n < 0           = False-fits _ NoDoc               = False-fits _ Empty               = True-fits _ (NilAbove _)        = True-fits n (TextBeside _ sl p) = fits (n - sl) p-fits _ (Above {})          = error "fits Above"-fits _ (Beside {})         = error "fits Beside"-fits _ (Union {})          = error "fits Union"-fits _ (Nest {})           = error "fits Nest"---- | @first@ returns its first argument if it is non-empty, otherwise its second.-first :: Doc -> Doc -> Doc-first p q | nonEmptySet p = p -- unused, because (get OneLineMode) is unused-          | otherwise     = q--nonEmptySet :: Doc -> Bool-nonEmptySet NoDoc              = False-nonEmptySet (_ `Union` _)      = True-nonEmptySet Empty              = True-nonEmptySet (NilAbove _)       = True-nonEmptySet (TextBeside _ _ p) = nonEmptySet p-nonEmptySet (Nest _ p)         = nonEmptySet p-nonEmptySet (Above {})         = error "nonEmptySet Above"-nonEmptySet (Beside {})        = error "nonEmptySet Beside"---- @oneLiner@ returns the one-line members of the given set of @GDoc@s.-oneLiner :: Doc -> Doc-oneLiner NoDoc               = NoDoc-oneLiner Empty               = Empty-oneLiner (NilAbove _)        = NoDoc-oneLiner (TextBeside s sl p) = textBeside_ s sl (oneLiner p)-oneLiner (Nest k p)          = nest_ k (oneLiner p)-oneLiner (p `Union` _)       = oneLiner p-oneLiner (Above {})          = error "oneLiner Above"-oneLiner (Beside {})         = error "oneLiner Beside"----- ------------------------------------------------------------------------------ Rendering---- | A rendering style.-data Style-  = Style { mode           :: Mode  -- ^ The rendering mode-          , lineLength     :: Int   -- ^ Length of line, in chars-          , ribbonsPerLine :: Float -- ^ Ratio of line length to ribbon length-          }---- | The default style (@mode=PageMode, lineLength=100, ribbonsPerLine=1.5@).-style :: Style-style = Style { lineLength = 100, ribbonsPerLine = 1.5, mode = PageMode }---- | Rendering mode.-data Mode = PageMode     -- ^ Normal-          | ZigZagMode   -- ^ With zig-zag cuts-          | LeftMode     -- ^ No indentation, infinitely long lines-          | OneLineMode  -- ^ All on one line---- | Render the @Doc@ to a String using the given @Style@.-renderStyle :: Style -> Doc -> String-renderStyle s = fullRender (mode s) (lineLength s) (ribbonsPerLine s)-                txtPrinter ""---- | Default TextDetails printer-txtPrinter :: TextDetails -> String -> String-txtPrinter (Chr c)    s  = c:s-txtPrinter (Str s1)   s2 = s1 ++ s2-txtPrinter (PStr s1)  s2 = unpackFS s1 ++ s2-txtPrinter (ZStr s1)  s2 = zString s1 ++ s2-txtPrinter (LStr s1)  s2 = unpackPtrString s1 ++ s2-txtPrinter (RStr n c) s2 = replicate n c ++ s2---- | The general rendering interface.-fullRender :: Mode                     -- ^ Rendering mode-           -> Int                      -- ^ Line length-           -> Float                    -- ^ Ribbons per line-           -> (TextDetails -> a -> a)  -- ^ What to do with text-           -> a                        -- ^ What to do at the end-           -> Doc                      -- ^ The document-           -> a                        -- ^ Result-fullRender OneLineMode _ _ txt end doc-  = easyDisplay spaceText (\_ y -> y) txt end (reduceDoc doc)-fullRender LeftMode    _ _ txt end doc-  = easyDisplay nlText first txt end (reduceDoc doc)--fullRender m lineLen ribbons txt rest doc-  = display m lineLen ribbonLen txt rest doc'-  where-    doc' = best bestLineLen ribbonLen (reduceDoc doc)--    bestLineLen, ribbonLen :: Int-    ribbonLen   = round (fromIntegral lineLen / ribbons)-    bestLineLen = case m of-                      ZigZagMode -> maxBound-                      _          -> lineLen--easyDisplay :: TextDetails-             -> (Doc -> Doc -> Doc)-             -> (TextDetails -> a -> a)-             -> a-             -> Doc-             -> a-easyDisplay nlSpaceText choose txt end-  = lay-  where-    lay NoDoc              = error "easyDisplay: NoDoc"-    lay (Union p q)        = lay (choose p q)-    lay (Nest _ p)         = lay p-    lay Empty              = end-    lay (NilAbove p)       = nlSpaceText `txt` lay p-    lay (TextBeside s _ p) = s `txt` lay p-    lay (Above {})         = error "easyDisplay Above"-    lay (Beside {})        = error "easyDisplay Beside"--display :: Mode -> Int -> Int -> (TextDetails -> a -> a) -> a -> Doc -> a-display m !page_width !ribbon_width txt end doc-  = case page_width - ribbon_width of { gap_width ->-    case gap_width `quot` 2 of { shift ->-    let-        lay k _            | k `seq` False = undefined-        lay k (Nest k1 p)  = lay (k + k1) p-        lay _ Empty        = end-        lay k (NilAbove p) = nlText `txt` lay k p-        lay k (TextBeside s sl p)-            = case m of-                    ZigZagMode |  k >= gap_width-                               -> nlText `txt` (-                                  Str (replicate shift '/') `txt` (-                                  nlText `txt`-                                  lay1 (k - shift) s sl p ))--                               |  k < 0-                               -> nlText `txt` (-                                  Str (replicate shift '\\') `txt` (-                                  nlText `txt`-                                  lay1 (k + shift) s sl p ))--                    _ -> lay1 k s sl p-        lay _ (Above {})   = error "display lay Above"-        lay _ (Beside {})  = error "display lay Beside"-        lay _ NoDoc        = error "display lay NoDoc"-        lay _ (Union {})   = error "display lay Union"--        lay1 !k s !sl p    = let !r = k + sl-                             in indent k (s `txt` lay2 r p)--        lay2 k _ | k `seq` False   = undefined-        lay2 k (NilAbove p)        = nlText `txt` lay k p-        lay2 k (TextBeside s sl p) = s `txt` lay2 (k + sl) p-        lay2 k (Nest _ p)          = lay2 k p-        lay2 _ Empty               = end-        lay2 _ (Above {})          = error "display lay2 Above"-        lay2 _ (Beside {})         = error "display lay2 Beside"-        lay2 _ NoDoc               = error "display lay2 NoDoc"-        lay2 _ (Union {})          = error "display lay2 Union"--        indent !n r                = RStr n ' ' `txt` r-    in-    lay 0 doc-    }}--printDoc :: Mode -> Int -> Handle -> Doc -> IO ()--- printDoc adds a newline to the end-printDoc mode cols hdl doc = printDoc_ mode cols hdl (doc $$ text "")--printDoc_ :: Mode -> Int -> Handle -> Doc -> IO ()--- printDoc_ does not add a newline at the end, so that--- successive calls can output stuff on the same line--- Rather like putStr vs putStrLn-printDoc_ LeftMode _ hdl doc-  = do { printLeftRender hdl doc; hFlush hdl }-printDoc_ mode pprCols hdl doc-  = do { fullRender mode pprCols 1.5 put done doc ;-         hFlush hdl }-  where-    put (Chr c)    next = hPutChar hdl c >> next-    put (Str s)    next = hPutStr  hdl s >> next-    put (PStr s)   next = hPutStr  hdl (unpackFS s) >> next-                          -- NB. not hPutFS, we want this to go through-                          -- the I/O library's encoding layer. (#3398)-    put (ZStr s)   next = hPutFZS  hdl s >> next-    put (LStr s)   next = hPutPtrString hdl s >> next-    put (RStr n c) next = hPutStr hdl (replicate n c) >> next--    done = return () -- hPutChar hdl '\n'--  -- some versions of hPutBuf will barf if the length is zero-hPutPtrString :: Handle -> PtrString -> IO ()-hPutPtrString _handle (PtrString _ 0) = return ()-hPutPtrString handle  (PtrString a l) = hPutBuf handle a l---- Printing output in LeftMode is performance critical: it's used when--- dumping C and assembly output, so we allow ourselves a few dirty--- hacks:------ (1) we specialise fullRender for LeftMode with IO output.------ (2) we add a layer of buffering on top of Handles.  Handles---     don't perform well with lots of hPutChars, which is mostly---     what we're doing here, because Handles have to be thread-safe---     and async exception-safe.  We only have a single thread and don't---     care about exceptions, so we add a layer of fast buffering---     over the Handle interface.--printLeftRender :: Handle -> Doc -> IO ()-printLeftRender hdl doc = do-  b <- newBufHandle hdl-  bufLeftRender b doc-  bFlush b--bufLeftRender :: BufHandle -> Doc -> IO ()-bufLeftRender b doc = layLeft b (reduceDoc doc)--layLeft :: BufHandle -> Doc -> IO ()-layLeft b _ | b `seq` False  = undefined -- make it strict in b-layLeft _ NoDoc              = error "layLeft: NoDoc"-layLeft b (Union p q)        = layLeft b $! first p q-layLeft b (Nest _ p)         = layLeft b $! p-layLeft b Empty              = bPutChar b '\n'-layLeft b (NilAbove p)       = p `seq` (bPutChar b '\n' >> layLeft b p)-layLeft b (TextBeside s _ p) = s `seq` (put b s >> layLeft b p)- where-    put b _ | b `seq` False = undefined-    put b (Chr c)    = bPutChar b c-    put b (Str s)    = bPutStr  b s-    put b (PStr s)   = bPutFS   b s-    put b (ZStr s)   = bPutFZS  b s-    put b (LStr s)   = bPutPtrString b s-    put b (RStr n c) = bPutReplicate b n c-layLeft _ _                  = panic "layLeft: Unhandled case"---- Define error=panic, for easier comparison with libraries/pretty.-error :: String -> a-error = panic
− compiler/utils/Stream.hs 
@@ -1,135 +0,0 @@--- ----------------------------------------------------------------------------------- (c) The University of Glasgow 2012------ Monadic streams------ ------------------------------------------------------------------------------module Stream (-    Stream(..), yield, liftIO,-    collect, collect_, consume, fromList,-    Stream.map, Stream.mapM, Stream.mapAccumL, Stream.mapAccumL_-  ) where--import GhcPrelude--import Control.Monad---- |--- @Stream m a b@ is a computation in some Monad @m@ that delivers a sequence--- of elements of type @a@ followed by a result of type @b@.------ More concretely, a value of type @Stream m a b@ can be run using @runStream@--- in the Monad @m@, and it delivers either------  * the final result: @Left b@, or---  * @Right (a,str)@, where @a@ is the next element in the stream, and @str@---    is a computation to get the rest of the stream.------ Stream is itself a Monad, and provides an operation 'yield' that--- produces a new element of the stream.  This makes it convenient to turn--- existing monadic computations into streams.------ The idea is that Stream is useful for making a monadic computation--- that produces values from time to time.  This can be used for--- knitting together two complex monadic operations, so that the--- producer does not have to produce all its values before the--- consumer starts consuming them.  We make the producer into a--- Stream, and the consumer pulls on the stream each time it wants a--- new value.----newtype Stream m a b = Stream { runStream :: m (Either b (a, Stream m a b)) }--instance Monad f => Functor (Stream f a) where-  fmap = liftM--instance Monad m => Applicative (Stream m a) where-  pure a = Stream (return (Left a))-  (<*>) = ap--instance Monad m => Monad (Stream m a) where--  Stream m >>= k = Stream $ do-                r <- m-                case r of-                  Left b        -> runStream (k b)-                  Right (a,str) -> return (Right (a, str >>= k))--yield :: Monad m => a -> Stream m a ()-yield a = Stream (return (Right (a, return ())))--liftIO :: IO a -> Stream IO b a-liftIO io = Stream $ io >>= return . Left---- | Turn a Stream into an ordinary list, by demanding all the elements.-collect :: Monad m => Stream m a () -> m [a]-collect str = go str []- where-  go str acc = do-    r <- runStream str-    case r of-      Left () -> return (reverse acc)-      Right (a, str') -> go str' (a:acc)---- | Turn a Stream into an ordinary list, by demanding all the elements.-collect_ :: Monad m => Stream m a r -> m ([a], r)-collect_ str = go str []- where-  go str acc = do-    r <- runStream str-    case r of-      Left r -> return (reverse acc, r)-      Right (a, str') -> go str' (a:acc)--consume :: Monad m => Stream m a b -> (a -> m ()) -> m b-consume str f = do-    r <- runStream str-    case r of-      Left ret -> return ret-      Right (a, str') -> do-        f a-        consume str' f---- | Turn a list into a 'Stream', by yielding each element in turn.-fromList :: Monad m => [a] -> Stream m a ()-fromList = mapM_ yield---- | Apply a function to each element of a 'Stream', lazily-map :: Monad m => (a -> b) -> Stream m a x -> Stream m b x-map f str = Stream $ do-   r <- runStream str-   case r of-     Left x -> return (Left x)-     Right (a, str') -> return (Right (f a, Stream.map f str'))---- | Apply a monadic operation to each element of a 'Stream', lazily-mapM :: Monad m => (a -> m b) -> Stream m a x -> Stream m b x-mapM f str = Stream $ do-   r <- runStream str-   case r of-     Left x -> return (Left x)-     Right (a, str') -> do-        b <- f a-        return (Right (b, Stream.mapM f str'))---- | analog of the list-based 'mapAccumL' on Streams.  This is a simple--- way to map over a Stream while carrying some state around.-mapAccumL :: Monad m => (c -> a -> m (c,b)) -> c -> Stream m a ()-          -> Stream m b c-mapAccumL f c str = Stream $ do-  r <- runStream str-  case r of-    Left  () -> return (Left c)-    Right (a, str') -> do-      (c',b) <- f c a-      return (Right (b, mapAccumL f c' str'))--mapAccumL_ :: Monad m => (c -> a -> m (c,b)) -> c -> Stream m a r-           -> Stream m b (c, r)-mapAccumL_ f c str = Stream $ do-  r <- runStream str-  case r of-    Left  r -> return (Left (c, r))-    Right (a, str') -> do-      (c',b) <- f c a-      return (Right (b, mapAccumL_ f c' str'))
− compiler/utils/StringBuffer.hs 
@@ -1,334 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The University of Glasgow, 1997-2006---Buffers for scanning string input stored in external arrays.--}--{-# LANGUAGE BangPatterns, CPP, MagicHash, UnboxedTuples #-}-{-# OPTIONS_GHC -O2 #-}--- We always optimise this, otherwise performance of a non-optimised--- compiler is severely affected--module StringBuffer-       (-        StringBuffer(..),-        -- non-abstract for vs\/HaskellService--         -- * Creation\/destruction-        hGetStringBuffer,-        hGetStringBufferBlock,-        hPutStringBuffer,-        appendStringBuffers,-        stringToStringBuffer,--        -- * Inspection-        nextChar,-        currentChar,-        prevChar,-        atEnd,--        -- * Moving and comparison-        stepOn,-        offsetBytes,-        byteDiff,-        atLine,--        -- * Conversion-        lexemeToString,-        lexemeToFastString,-        decodePrevNChars,--         -- * Parsing integers-        parseUnsignedInteger,-       ) where--#include "HsVersions.h"--import GhcPrelude--import Encoding-import FastString-import FastFunctions-import PlainPanic-import Util--import Data.Maybe-import Control.Exception-import System.IO-import System.IO.Unsafe         ( unsafePerformIO )-import GHC.IO.Encoding.UTF8     ( mkUTF8 )-import GHC.IO.Encoding.Failure  ( CodingFailureMode(IgnoreCodingFailure) )--import GHC.Exts--import Foreign---- -------------------------------------------------------------------------------- The StringBuffer type---- |A StringBuffer is an internal pointer to a sized chunk of bytes.--- The bytes are intended to be *immutable*.  There are pure--- operations to read the contents of a StringBuffer.------ A StringBuffer may have a finalizer, depending on how it was--- obtained.----data StringBuffer- = StringBuffer {-     buf :: {-# UNPACK #-} !(ForeignPtr Word8),-     len :: {-# UNPACK #-} !Int,        -- length-     cur :: {-# UNPACK #-} !Int         -- current pos-  }-  -- The buffer is assumed to be UTF-8 encoded, and furthermore-  -- we add three @\'\\0\'@ bytes to the end as sentinels so that the-  -- decoder doesn't have to check for overflow at every single byte-  -- of a multibyte sequence.--instance Show StringBuffer where-        showsPrec _ s = showString "<stringbuffer("-                      . shows (len s) . showString "," . shows (cur s)-                      . showString ")>"---- -------------------------------------------------------------------------------- Creation / Destruction---- | Read a file into a 'StringBuffer'.  The resulting buffer is automatically--- managed by the garbage collector.-hGetStringBuffer :: FilePath -> IO StringBuffer-hGetStringBuffer fname = do-   h <- openBinaryFile fname ReadMode-   size_i <- hFileSize h-   offset_i <- skipBOM h size_i 0  -- offset is 0 initially-   let size = fromIntegral $ size_i - offset_i-   buf <- mallocForeignPtrArray (size+3)-   withForeignPtr buf $ \ptr -> do-     r <- if size == 0 then return 0 else hGetBuf h ptr size-     hClose h-     if (r /= size)-        then ioError (userError "short read of file")-        else newUTF8StringBuffer buf ptr size--hGetStringBufferBlock :: Handle -> Int -> IO StringBuffer-hGetStringBufferBlock handle wanted-    = do size_i <- hFileSize handle-         offset_i <- hTell handle >>= skipBOM handle size_i-         let size = min wanted (fromIntegral $ size_i-offset_i)-         buf <- mallocForeignPtrArray (size+3)-         withForeignPtr buf $ \ptr ->-             do r <- if size == 0 then return 0 else hGetBuf handle ptr size-                if r /= size-                   then ioError (userError $ "short read of file: "++show(r,size,size_i,handle))-                   else newUTF8StringBuffer buf ptr size--hPutStringBuffer :: Handle -> StringBuffer -> IO ()-hPutStringBuffer hdl (StringBuffer buf len cur)-    = do withForeignPtr (plusForeignPtr buf cur) $ \ptr ->-             hPutBuf hdl ptr len---- | Skip the byte-order mark if there is one (see #1744 and #6016),--- and return the new position of the handle in bytes.------ This is better than treating #FEFF as whitespace,--- because that would mess up layout.  We don't have a concept--- of zero-width whitespace in Haskell: all whitespace codepoints--- have a width of one column.-skipBOM :: Handle -> Integer -> Integer -> IO Integer-skipBOM h size offset =-  -- Only skip BOM at the beginning of a file.-  if size > 0 && offset == 0-    then do-      -- Validate assumption that handle is in binary mode.-      ASSERTM( hGetEncoding h >>= return . isNothing )-      -- Temporarily select utf8 encoding with error ignoring,-      -- to make `hLookAhead` and `hGetChar` return full Unicode characters.-      bracket_ (hSetEncoding h safeEncoding) (hSetBinaryMode h True) $ do-        c <- hLookAhead h-        if c == '\xfeff'-          then hGetChar h >> hTell h-          else return offset-    else return offset-  where-    safeEncoding = mkUTF8 IgnoreCodingFailure--newUTF8StringBuffer :: ForeignPtr Word8 -> Ptr Word8 -> Int -> IO StringBuffer-newUTF8StringBuffer buf ptr size = do-  pokeArray (ptr `plusPtr` size :: Ptr Word8) [0,0,0]-  -- sentinels for UTF-8 decoding-  return $ StringBuffer buf size 0--appendStringBuffers :: StringBuffer -> StringBuffer -> IO StringBuffer-appendStringBuffers sb1 sb2-    = do newBuf <- mallocForeignPtrArray (size+3)-         withForeignPtr newBuf $ \ptr ->-          withForeignPtr (buf sb1) $ \sb1Ptr ->-           withForeignPtr (buf sb2) $ \sb2Ptr ->-             do copyArray ptr (sb1Ptr `advancePtr` cur sb1) sb1_len-                copyArray (ptr `advancePtr` sb1_len) (sb2Ptr `advancePtr` cur sb2) sb2_len-                pokeArray (ptr `advancePtr` size) [0,0,0]-                return (StringBuffer newBuf size 0)-    where sb1_len = calcLen sb1-          sb2_len = calcLen sb2-          calcLen sb = len sb - cur sb-          size =  sb1_len + sb2_len---- | Encode a 'String' into a 'StringBuffer' as UTF-8.  The resulting buffer--- is automatically managed by the garbage collector.-stringToStringBuffer :: String -> StringBuffer-stringToStringBuffer str =- unsafePerformIO $ do-  let size = utf8EncodedLength str-  buf <- mallocForeignPtrArray (size+3)-  withForeignPtr buf $ \ptr -> do-    utf8EncodeString ptr str-    pokeArray (ptr `plusPtr` size :: Ptr Word8) [0,0,0]-    -- sentinels for UTF-8 decoding-  return (StringBuffer buf size 0)---- -------------------------------------------------------------------------------- Grab a character---- | Return the first UTF-8 character of a nonempty 'StringBuffer' and as well--- the remaining portion (analogous to 'Data.List.uncons').  __Warning:__ The--- behavior is undefined if the 'StringBuffer' is empty.  The result shares--- the same buffer as the original.  Similar to 'utf8DecodeChar', if the--- character cannot be decoded as UTF-8, @\'\\0\'@ is returned.-{-# INLINE nextChar #-}-nextChar :: StringBuffer -> (Char,StringBuffer)-nextChar (StringBuffer buf len (I# cur#)) =-  -- Getting our fingers dirty a little here, but this is performance-critical-  inlinePerformIO $ do-    withForeignPtr buf $ \(Ptr a#) -> do-        case utf8DecodeChar# (a# `plusAddr#` cur#) of-          (# c#, nBytes# #) ->-             let cur' = I# (cur# +# nBytes#) in-             return (C# c#, StringBuffer buf len cur')---- | Return the first UTF-8 character of a nonempty 'StringBuffer' (analogous--- to 'Data.List.head').  __Warning:__ The behavior is undefined if the--- 'StringBuffer' is empty.  Similar to 'utf8DecodeChar', if the character--- cannot be decoded as UTF-8, @\'\\0\'@ is returned.-currentChar :: StringBuffer -> Char-currentChar = fst . nextChar--prevChar :: StringBuffer -> Char -> Char-prevChar (StringBuffer _   _   0)   deflt = deflt-prevChar (StringBuffer buf _   cur) _     =-  inlinePerformIO $ do-    withForeignPtr buf $ \p -> do-      p' <- utf8PrevChar (p `plusPtr` cur)-      return (fst (utf8DecodeChar p'))---- -------------------------------------------------------------------------------- Moving---- | Return a 'StringBuffer' with the first UTF-8 character removed (analogous--- to 'Data.List.tail').  __Warning:__ The behavior is undefined if the--- 'StringBuffer' is empty.  The result shares the same buffer as the--- original.-stepOn :: StringBuffer -> StringBuffer-stepOn s = snd (nextChar s)---- | Return a 'StringBuffer' with the first @n@ bytes removed.  __Warning:__--- If there aren't enough characters, the returned 'StringBuffer' will be--- invalid and any use of it may lead to undefined behavior.  The result--- shares the same buffer as the original.-offsetBytes :: Int                      -- ^ @n@, the number of bytes-            -> StringBuffer-            -> StringBuffer-offsetBytes i s = s { cur = cur s + i }---- | Compute the difference in offset between two 'StringBuffer's that share--- the same buffer.  __Warning:__ The behavior is undefined if the--- 'StringBuffer's use separate buffers.-byteDiff :: StringBuffer -> StringBuffer -> Int-byteDiff s1 s2 = cur s2 - cur s1---- | Check whether a 'StringBuffer' is empty (analogous to 'Data.List.null').-atEnd :: StringBuffer -> Bool-atEnd (StringBuffer _ l c) = l == c---- | Computes a 'StringBuffer' which points to the first character of the--- wanted line. Lines begin at 1.-atLine :: Int -> StringBuffer -> Maybe StringBuffer-atLine line sb@(StringBuffer buf len _) =-  inlinePerformIO $-    withForeignPtr buf $ \p -> do-      p' <- skipToLine line len p-      if p' == nullPtr-        then return Nothing-        else-          let-            delta = p' `minusPtr` p-          in return $ Just (sb { cur = delta-                               , len = len - delta-                               })--skipToLine :: Int -> Int -> Ptr Word8 -> IO (Ptr Word8)-skipToLine !line !len !op0 = go 1 op0-  where-    !opend = op0 `plusPtr` len--    go !i_line !op-      | op >= opend    = pure nullPtr-      | i_line == line = pure op-      | otherwise      = do-          w <- peek op :: IO Word8-          case w of-            10 -> go (i_line + 1) (plusPtr op 1)-            13 -> do-              -- this is safe because a 'StringBuffer' is-              -- guaranteed to have 3 bytes sentinel values.-              w' <- peek (plusPtr op 1) :: IO Word8-              case w' of-                10 -> go (i_line + 1) (plusPtr op 2)-                _  -> go (i_line + 1) (plusPtr op 1)-            _  -> go i_line (plusPtr op 1)---- -------------------------------------------------------------------------------- Conversion---- | Decode the first @n@ bytes of a 'StringBuffer' as UTF-8 into a 'String'.--- Similar to 'utf8DecodeChar', if the character cannot be decoded as UTF-8,--- they will be replaced with @\'\\0\'@.-lexemeToString :: StringBuffer-               -> Int                   -- ^ @n@, the number of bytes-               -> String-lexemeToString _ 0 = ""-lexemeToString (StringBuffer buf _ cur) bytes =-  utf8DecodeStringLazy buf cur bytes--lexemeToFastString :: StringBuffer-                   -> Int               -- ^ @n@, the number of bytes-                   -> FastString-lexemeToFastString _ 0 = nilFS-lexemeToFastString (StringBuffer buf _ cur) len =-   inlinePerformIO $-     withForeignPtr buf $ \ptr ->-       return $! mkFastStringBytes (ptr `plusPtr` cur) len---- | Return the previous @n@ characters (or fewer if we are less than @n@--- characters into the buffer.-decodePrevNChars :: Int -> StringBuffer -> String-decodePrevNChars n (StringBuffer buf _ cur) =-    inlinePerformIO $ withForeignPtr buf $ \p0 ->-      go p0 n "" (p0 `plusPtr` (cur - 1))-  where-    go :: Ptr Word8 -> Int -> String -> Ptr Word8 -> IO String-    go buf0 n acc p | n == 0 || buf0 >= p = return acc-    go buf0 n acc p = do-        p' <- utf8PrevChar p-        let (c,_) = utf8DecodeChar p'-        go buf0 (n - 1) (c:acc) p'---- -------------------------------------------------------------------------------- Parsing integer strings in various bases-parseUnsignedInteger :: StringBuffer -> Int -> Integer -> (Char->Int) -> Integer-parseUnsignedInteger (StringBuffer buf _ cur) len radix char_to_int-  = inlinePerformIO $ withForeignPtr buf $ \ptr -> return $! let-    go i x | i == len  = x-           | otherwise = case fst (utf8DecodeChar (ptr `plusPtr` (cur + i))) of-               '_'  -> go (i + 1) x    -- skip "_" (#14473)-               char -> go (i + 1) (x * radix + toInteger (char_to_int char))-  in go 0 0
− compiler/utils/TrieMap.hs 
@@ -1,406 +0,0 @@-{--(c) The University of Glasgow 2006-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998--}--{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE TypeSynonymInstances #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE UndecidableInstances #-}-module TrieMap(-   -- * Maps over 'Maybe' values-   MaybeMap,-   -- * Maps over 'List' values-   ListMap,-   -- * Maps over 'Literal's-   LiteralMap,-   -- * 'TrieMap' class-   TrieMap(..), insertTM, deleteTM,--   -- * Things helpful for adding additional Instances.-   (>.>), (|>), (|>>), XT,-   foldMaybe,-   -- * Map for leaf compression-   GenMap,-   lkG, xtG, mapG, fdG,-   xtList, lkList-- ) where--import GhcPrelude--import GHC.Types.Literal-import GHC.Types.Unique.DFM-import GHC.Types.Unique( Unique )--import qualified Data.Map    as Map-import qualified Data.IntMap as IntMap-import Outputable-import Control.Monad( (>=>) )-import Data.Kind( Type )--{--This module implements TrieMaps, which are finite mappings-whose key is a structured value like a CoreExpr or Type.--This file implements tries over general data structures.-Implementation for tries over Core Expressions/Types are-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-generalization of the Trie Data Structure"; there is also an accessible-description of the idea in Okasaki's book "Purely Functional Data-Structures", Section 10.3.2--************************************************************************-*                                                                      *-                   The TrieMap class-*                                                                      *-************************************************************************--}--type XT a = Maybe a -> Maybe a  -- How to alter a non-existent elt (Nothing)-                                --               or an existing elt (Just)--class TrieMap m where-   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-   mapTM    :: (a->b) -> m a -> m b--   foldTM   :: (a -> b -> b) -> m a -> b -> b-      -- The unusual argument order here makes-      -- it easy to compose calls to foldTM;-      -- see for example fdE below--insertTM :: TrieMap m => Key m -> a -> m a -> m a-insertTM k v m = alterTM k (\_ -> Just v) m--deleteTM :: TrieMap m => Key m -> m a -> m a-deleteTM k m = alterTM k (\_ -> Nothing) m--------------------------- Recall that---   Control.Monad.(>=>) :: (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c--(>.>) :: (a -> b) -> (b -> c) -> a -> c--- Reverse function composition (do f first, then g)-infixr 1 >.>-(f >.> g) x = g (f x)-infixr 1 |>, |>>--(|>) :: a -> (a->b) -> b     -- Reverse application-x |> f = f x-------------------------(|>>) :: TrieMap m2-      => (XT (m2 a) -> m1 (m2 a) -> m1 (m2 a))-      -> (m2 a -> m2 a)-      -> m1 (m2 a) -> m1 (m2 a)-(|>>) f g = f (Just . g . deMaybe)--deMaybe :: TrieMap m => Maybe (m a) -> m a-deMaybe Nothing  = emptyTM-deMaybe (Just m) = m--{--************************************************************************-*                                                                      *-                   IntMaps-*                                                                      *-************************************************************************--}--instance TrieMap IntMap.IntMap where-  type Key IntMap.IntMap = Int-  emptyTM = IntMap.empty-  lookupTM k m = IntMap.lookup k m-  alterTM = xtInt-  foldTM k m z = IntMap.foldr k z m-  mapTM f m = IntMap.map f m--xtInt :: Int -> XT a -> IntMap.IntMap a -> IntMap.IntMap a-xtInt k f m = IntMap.alter f k m--instance Ord k => TrieMap (Map.Map k) where-  type Key (Map.Map k) = k-  emptyTM = Map.empty-  lookupTM = Map.lookup-  alterTM k f m = Map.alter f k m-  foldTM k m z = Map.foldr k z m-  mapTM f m = Map.map f m---{--Note [foldTM determinism]-~~~~~~~~~~~~~~~~~~~~~~~~~-We want foldTM to be deterministic, which is why we have an instance of-TrieMap for UniqDFM, but not for UniqFM. Here's an example of some things that-go wrong if foldTM is nondeterministic. Consider:--  f a b = return (a <> b)--Depending on the order that the typechecker generates constraints you-get either:--  f :: (Monad m, Monoid a) => a -> a -> m a--or:--  f :: (Monoid a, Monad m) => a -> a -> m a--The generated code will be different after desugaring as the dictionaries-will be bound in different orders, leading to potential ABI incompatibility.--One way to solve this would be to notice that the typeclasses could be-sorted alphabetically.--Unfortunately that doesn't quite work with this example:--  f a b = let x = a <> a; y = b <> b in x--where you infer:--  f :: (Monoid m, Monoid m1) => m1 -> m -> m1--or:--  f :: (Monoid m1, Monoid m) => m1 -> m -> m1--Here you could decide to take the order of the type variables in the type-according to depth first traversal and use it to order the constraints.--The real trouble starts when the user enables incoherent instances and-the compiler has to make an arbitrary choice. Consider:--  class T a b where-    go :: a -> b -> String--  instance (Show b) => T Int b where-    go a b = show a ++ show b--  instance (Show a) => T a Bool where-    go a b = show a ++ show b--  f = go 10 True--GHC is free to choose either dictionary to implement f, but for the sake of-determinism we'd like it to be consistent when compiling the same sources-with the same flags.--inert_dicts :: DictMap is implemented with a TrieMap. In getUnsolvedInerts it-gets converted to a bag of (Wanted) Cts using a fold. Then in-solve_simple_wanteds it's merged with other WantedConstraints. We want the-conversion to a bag to be deterministic. For that purpose we use UniqDFM-instead of UniqFM to implement the TrieMap.--See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for more details on how it's made-deterministic.--}--instance TrieMap UniqDFM where-  type Key UniqDFM = Unique-  emptyTM = emptyUDFM-  lookupTM k m = lookupUDFM m k-  alterTM k f m = alterUDFM f m k-  foldTM k m z = foldUDFM k z m-  mapTM f m = mapUDFM f m--{--************************************************************************-*                                                                      *-                   Maybes-*                                                                      *-************************************************************************--If              m is a map from k -> val-then (MaybeMap m) is a map from (Maybe k) -> val--}--data MaybeMap m a = MM { mm_nothing  :: Maybe a, mm_just :: m a }--instance TrieMap m => TrieMap (MaybeMap m) where-   type Key (MaybeMap m) = Maybe (Key m)-   emptyTM  = MM { mm_nothing = Nothing, mm_just = emptyTM }-   lookupTM = lkMaybe lookupTM-   alterTM  = xtMaybe alterTM-   foldTM   = fdMaybe-   mapTM    = mapMb--mapMb :: TrieMap m => (a->b) -> MaybeMap m a -> MaybeMap m b-mapMb f (MM { mm_nothing = mn, mm_just = mj })-  = MM { mm_nothing = fmap f mn, mm_just = mapTM f mj }--lkMaybe :: (forall b. k -> m b -> Maybe b)-        -> Maybe k -> MaybeMap m a -> Maybe a-lkMaybe _  Nothing  = mm_nothing-lkMaybe lk (Just x) = mm_just >.> lk x--xtMaybe :: (forall b. k -> XT b -> m b -> m b)-        -> Maybe k -> XT a -> MaybeMap m a -> MaybeMap m a-xtMaybe _  Nothing  f m = m { mm_nothing  = f (mm_nothing m) }-xtMaybe tr (Just x) f m = m { mm_just = mm_just m |> tr x f }--fdMaybe :: TrieMap m => (a -> b -> b) -> MaybeMap m a -> b -> b-fdMaybe k m = foldMaybe k (mm_nothing m)-            . foldTM k (mm_just m)--{--************************************************************************-*                                                                      *-                   Lists-*                                                                      *-************************************************************************--}--data ListMap m a-  = LM { lm_nil  :: Maybe a-       , lm_cons :: m (ListMap m a) }--instance TrieMap m => TrieMap (ListMap m) where-   type Key (ListMap m) = [Key m]-   emptyTM  = LM { lm_nil = Nothing, lm_cons = emptyTM }-   lookupTM = lkList lookupTM-   alterTM  = xtList alterTM-   foldTM   = fdList-   mapTM    = mapList--instance (TrieMap m, Outputable a) => Outputable (ListMap m a) where-  ppr m = text "List elts" <+> ppr (foldTM (:) m [])--mapList :: TrieMap m => (a->b) -> ListMap m a -> ListMap m b-mapList f (LM { lm_nil = mnil, lm_cons = mcons })-  = LM { lm_nil = fmap f mnil, lm_cons = mapTM (mapTM f) mcons }--lkList :: TrieMap m => (forall b. k -> m b -> Maybe b)-        -> [k] -> ListMap m a -> Maybe a-lkList _  []     = lm_nil-lkList lk (x:xs) = lm_cons >.> lk x >=> lkList lk xs--xtList :: TrieMap m => (forall b. k -> XT b -> m b -> m b)-        -> [k] -> XT a -> ListMap m a -> ListMap m a-xtList _  []     f m = m { lm_nil  = f (lm_nil m) }-xtList tr (x:xs) f m = m { lm_cons = lm_cons m |> tr x |>> xtList tr xs f }--fdList :: forall m a b. TrieMap m-       => (a -> b -> b) -> ListMap m a -> b -> b-fdList k m = foldMaybe k          (lm_nil m)-           . foldTM    (fdList k) (lm_cons m)--foldMaybe :: (a -> b -> b) -> Maybe a -> b -> b-foldMaybe _ Nothing  b = b-foldMaybe k (Just a) b = k a b--{--************************************************************************-*                                                                      *-                   Basic maps-*                                                                      *-************************************************************************--}--type LiteralMap  a = Map.Map Literal a--{--************************************************************************-*                                                                      *-                   GenMap-*                                                                      *-************************************************************************--Note [Compressed TrieMap]-~~~~~~~~~~~~~~~~~~~~~~~~~--The GenMap constructor augments TrieMaps with leaf compression.  This helps-solve the performance problem detailed in #9960: suppose we have a handful-H of entries in a TrieMap, each with a very large key, size K. If you fold over-such a TrieMap you'd expect time O(H). That would certainly be true of an-association list! But with TrieMap we actually have to navigate down a long-singleton structure to get to the elements, so it takes time O(K*H).  This-can really hurt on many type-level computation benchmarks:-see for example T9872d.--The point of a TrieMap is that you need to navigate to the point where only one-key remains, and then things should be fast.  So the point of a SingletonMap-is that, once we are down to a single (key,value) pair, we stop and-just use SingletonMap.--'EmptyMap' provides an even more basic (but essential) optimization: if there is-nothing in the map, don't bother building out the (possibly infinite) recursive-TrieMap structure!--Compressed triemaps are heavily used by GHC.Core.Map. So we have to mark some things-as INLINEABLE to permit specialization.--}--data GenMap m a-   = EmptyMap-   | SingletonMap (Key m) a-   | MultiMap (m a)--instance (Outputable a, Outputable (m a)) => Outputable (GenMap m a) where-  ppr EmptyMap = text "Empty map"-  ppr (SingletonMap _ v) = text "Singleton map" <+> ppr v-  ppr (MultiMap m) = ppr m---- TODO undecidable instance-instance (Eq (Key m), TrieMap m) => TrieMap (GenMap m) where-   type Key (GenMap m) = Key m-   emptyTM  = EmptyMap-   lookupTM = lkG-   alterTM  = xtG-   foldTM   = fdG-   mapTM    = mapG----We want to be able to specialize these functions when defining eg---tries over (GenMap CoreExpr) which requires INLINEABLE--{-# INLINEABLE lkG #-}-lkG :: (Eq (Key m), TrieMap m) => Key m -> GenMap m a -> Maybe a-lkG _ EmptyMap                         = Nothing-lkG k (SingletonMap k' v') | k == k'   = Just v'-                           | otherwise = Nothing-lkG k (MultiMap m)                     = lookupTM k m--{-# INLINEABLE xtG #-}-xtG :: (Eq (Key m), TrieMap m) => Key m -> XT a -> GenMap m a -> GenMap m a-xtG k f EmptyMap-    = case f Nothing of-        Just v  -> SingletonMap k v-        Nothing -> EmptyMap-xtG k f m@(SingletonMap k' v')-    | k' == k-    -- The new key matches the (single) key already in the tree.  Hence,-    -- apply @f@ to @Just v'@ and build a singleton or empty map depending-    -- on the 'Just'/'Nothing' response respectively.-    = case f (Just v') of-        Just v'' -> SingletonMap k' v''-        Nothing  -> EmptyMap-    | otherwise-    -- We've hit a singleton tree for a different key than the one we are-    -- searching for. Hence apply @f@ to @Nothing@. If result is @Nothing@ then-    -- we can just return the old map. If not, we need a map with *two*-    -- entries. The easiest way to do that is to insert two items into an empty-    -- map of type @m a@.-    = case f Nothing of-        Nothing  -> m-        Just v   -> emptyTM |> alterTM k' (const (Just v'))-                           >.> alterTM k  (const (Just v))-                           >.> MultiMap-xtG k f (MultiMap m) = MultiMap (alterTM k f m)--{-# INLINEABLE mapG #-}-mapG :: TrieMap m => (a -> b) -> GenMap m a -> GenMap m b-mapG _ EmptyMap = EmptyMap-mapG f (SingletonMap k v) = SingletonMap k (f v)-mapG f (MultiMap m) = MultiMap (mapTM f m)--{-# INLINEABLE fdG #-}-fdG :: TrieMap m => (a -> b -> b) -> GenMap m a -> b -> b-fdG _ EmptyMap = \z -> z-fdG k (SingletonMap _ v) = \z -> k v z-fdG k (MultiMap m) = foldTM k m
− compiler/utils/Util.hs 
@@ -1,1465 +0,0 @@--- (c) The University of Glasgow 2006--{-# LANGUAGE CPP #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE TupleSections #-}--{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}---- | Highly random utility functions----module Util (-        -- * Flags dependent on the compiler build-        ghciSupported, debugIsOn,-        isWindowsHost, isDarwinHost,--        -- * Miscellaneous higher-order functions-        applyWhen, nTimes,--        -- * General list processing-        zipEqual, zipWithEqual, zipWith3Equal, zipWith4Equal,-        zipLazy, stretchZipWith, zipWithAndUnzip, zipAndUnzip,--        zipWithLazy, zipWith3Lazy,--        filterByList, filterByLists, partitionByList,--        unzipWith,--        mapFst, mapSnd, chkAppend,-        mapAndUnzip, mapAndUnzip3, mapAccumL2,-        filterOut, partitionWith,--        dropWhileEndLE, spanEnd, last2, lastMaybe,--        foldl1', foldl2, count, countWhile, all2,--        lengthExceeds, lengthIs, lengthIsNot,-        lengthAtLeast, lengthAtMost, lengthLessThan,-        listLengthCmp, atLength,-        equalLength, compareLength, leLength, ltLength,--        isSingleton, only, singleton,-        notNull, snocView,--        isIn, isn'tIn,--        chunkList,--        changeLast,--        whenNonEmpty,--        -- * Tuples-        fstOf3, sndOf3, thdOf3,-        firstM, first3M, secondM,-        fst3, snd3, third3,-        uncurry3,-        liftFst, liftSnd,--        -- * List operations controlled by another list-        takeList, dropList, splitAtList, split,-        dropTail, capitalise,--        -- * Sorting-        sortWith, minWith, nubSort, ordNub,--        -- * Comparisons-        isEqual, eqListBy, eqMaybeBy,-        thenCmp, cmpList,-        removeSpaces,-        (<&&>), (<||>),--        -- * Edit distance-        fuzzyMatch, fuzzyLookup,--        -- * Transitive closures-        transitiveClosure,--        -- * Strictness-        seqList, strictMap,--        -- * Module names-        looksLikeModuleName,-        looksLikePackageName,--        -- * Argument processing-        getCmd, toCmdArgs, toArgs,--        -- * Integers-        exactLog2,--        -- * Floating point-        readRational,-        readHexRational,--        -- * IO-ish utilities-        doesDirNameExist,-        getModificationUTCTime,-        modificationTimeIfExists,-        withAtomicRename,--        global, consIORef, globalM,-        sharedGlobal, sharedGlobalM,--        -- * Filenames and paths-        Suffix,-        splitLongestPrefix,-        escapeSpaces,-        Direction(..), reslash,-        makeRelativeTo,--        -- * Utils for defining Data instances-        abstractConstr, abstractDataType, mkNoRepType,--        -- * Utils for printing C code-        charToC,--        -- * Hashing-        hashString,--        -- * Call stacks-        HasCallStack,-        HasDebugCallStack,--        -- * Utils for flags-        OverridingBool(..),-        overrideWith,-    ) where--#include "HsVersions.h"--import GhcPrelude--import Exception-import PlainPanic--import Data.Data-import Data.IORef       ( IORef, newIORef, atomicModifyIORef' )-import System.IO.Unsafe ( unsafePerformIO )-import Data.List        hiding (group)-import Data.List.NonEmpty  ( NonEmpty(..) )--import GHC.Exts-import GHC.Stack (HasCallStack)--import Control.Applicative ( liftA2 )-import Control.Monad    ( liftM, guard )-import Control.Monad.IO.Class ( MonadIO, liftIO )-import GHC.Conc.Sync ( sharedCAF )-import System.IO.Error as IO ( isDoesNotExistError )-import System.Directory ( doesDirectoryExist, getModificationTime, renameFile )-import System.FilePath--import Data.Char        ( isUpper, isAlphaNum, isSpace, chr, ord, isDigit, toUpper-                        , isHexDigit, digitToInt )-import Data.Int-import Data.Ratio       ( (%) )-import Data.Ord         ( comparing )-import Data.Bits-import Data.Word-import qualified Data.IntMap as IM-import qualified Data.Set as Set--import Data.Time--#if defined(DEBUG)-import {-# SOURCE #-} Outputable ( warnPprTrace, text )-#endif--infixr 9 `thenCmp`--{--************************************************************************-*                                                                      *-\subsection{Is DEBUG on, are we on Windows, etc?}-*                                                                      *-************************************************************************--These booleans are global constants, set by CPP flags.  They allow us to-recompile a single module (this one) to change whether or not debug output-appears. They sometimes let us avoid even running CPP elsewhere.--It's important that the flags are literal constants (True/False). Then,-with -0, tests of the flags in other modules will simplify to the correct-branch of the conditional, thereby dropping debug code altogether when-the flags are off.--}--ghciSupported :: Bool-#if defined(HAVE_INTERNAL_INTERPRETER)-ghciSupported = True-#else-ghciSupported = False-#endif--debugIsOn :: Bool-#if defined(DEBUG)-debugIsOn = True-#else-debugIsOn = False-#endif--isWindowsHost :: Bool-#if defined(mingw32_HOST_OS)-isWindowsHost = True-#else-isWindowsHost = False-#endif--isDarwinHost :: Bool-#if defined(darwin_HOST_OS)-isDarwinHost = True-#else-isDarwinHost = False-#endif--{--************************************************************************-*                                                                      *-\subsection{Miscellaneous higher-order functions}-*                                                                      *-************************************************************************--}---- | Apply a function iff some condition is met.-applyWhen :: Bool -> (a -> a) -> a -> a-applyWhen True f x = f x-applyWhen _    _ x = x---- | A for loop: Compose a function with itself n times.  (nth rather than twice)-nTimes :: Int -> (a -> a) -> (a -> a)-nTimes 0 _ = id-nTimes 1 f = f-nTimes n f = f . nTimes (n-1) f--fstOf3   :: (a,b,c) -> a-sndOf3   :: (a,b,c) -> b-thdOf3   :: (a,b,c) -> c-fstOf3      (a,_,_) =  a-sndOf3      (_,b,_) =  b-thdOf3      (_,_,c) =  c--fst3 :: (a -> d) -> (a, b, c) -> (d, b, c)-fst3 f (a, b, c) = (f a, b, c)--snd3 :: (b -> d) -> (a, b, c) -> (a, d, c)-snd3 f (a, b, c) = (a, f b, c)--third3 :: (c -> d) -> (a, b, c) -> (a, b, d)-third3 f (a, b, c) = (a, b, f c)--uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d-uncurry3 f (a, b, c) = f a b c--liftFst :: (a -> b) -> (a, c) -> (b, c)-liftFst f (a,c) = (f a, c)--liftSnd :: (a -> b) -> (c, a) -> (c, b)-liftSnd f (c,a) = (c, f a)--firstM :: Monad m => (a -> m c) -> (a, b) -> m (c, b)-firstM f (x, y) = liftM (\x' -> (x', y)) (f x)--first3M :: Monad m => (a -> m d) -> (a, b, c) -> m (d, b, c)-first3M f (x, y, z) = liftM (\x' -> (x', y, z)) (f x)--secondM :: Monad m => (b -> m c) -> (a, b) -> m (a, c)-secondM f (x, y) = (x,) <$> f y--{--************************************************************************-*                                                                      *-\subsection[Utils-lists]{General list processing}-*                                                                      *-************************************************************************--}--filterOut :: (a->Bool) -> [a] -> [a]--- ^ Like filter, only it reverses the sense of the test-filterOut _ [] = []-filterOut p (x:xs) | p x       = filterOut p xs-                   | otherwise = x : filterOut p xs--partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])--- ^ Uses a function to determine which of two output lists an input element should join-partitionWith _ [] = ([],[])-partitionWith f (x:xs) = case f x of-                         Left  b -> (b:bs, cs)-                         Right c -> (bs, c:cs)-    where (bs,cs) = partitionWith f xs--chkAppend :: [a] -> [a] -> [a]--- Checks for the second argument being empty--- Used in situations where that situation is common-chkAppend xs ys-  | null ys   = xs-  | otherwise = xs ++ ys--{--A paranoid @zip@ (and some @zipWith@ friends) that checks the lists-are of equal length.  Alastair Reid thinks this should only happen if-DEBUGging on; hey, why not?--}--zipEqual        :: String -> [a] -> [b] -> [(a,b)]-zipWithEqual    :: String -> (a->b->c) -> [a]->[b]->[c]-zipWith3Equal   :: String -> (a->b->c->d) -> [a]->[b]->[c]->[d]-zipWith4Equal   :: String -> (a->b->c->d->e) -> [a]->[b]->[c]->[d]->[e]--#if !defined(DEBUG)-zipEqual      _ = zip-zipWithEqual  _ = zipWith-zipWith3Equal _ = zipWith3-zipWith4Equal _ = zipWith4-#else-zipEqual _   []     []     = []-zipEqual msg (a:as) (b:bs) = (a,b) : zipEqual msg as bs-zipEqual msg _      _      = panic ("zipEqual: unequal lists: "++msg)--zipWithEqual msg z (a:as) (b:bs)=  z a b : zipWithEqual msg z as bs-zipWithEqual _   _ [] []        =  []-zipWithEqual msg _ _ _          =  panic ("zipWithEqual: unequal lists: "++msg)--zipWith3Equal msg z (a:as) (b:bs) (c:cs)-                                =  z a b c : zipWith3Equal msg z as bs cs-zipWith3Equal _   _ [] []  []   =  []-zipWith3Equal msg _ _  _   _    =  panic ("zipWith3Equal: unequal lists: "++msg)--zipWith4Equal msg z (a:as) (b:bs) (c:cs) (d:ds)-                                =  z a b c d : zipWith4Equal msg z as bs cs ds-zipWith4Equal _   _ [] [] [] [] =  []-zipWith4Equal msg _ _  _  _  _  =  panic ("zipWith4Equal: unequal lists: "++msg)-#endif---- | 'zipLazy' is a kind of 'zip' that is lazy in the second list (observe the ~)-zipLazy :: [a] -> [b] -> [(a,b)]-zipLazy []     _       = []-zipLazy (x:xs) ~(y:ys) = (x,y) : zipLazy xs ys---- | 'zipWithLazy' is like 'zipWith' but is lazy in the second list.--- The length of the output is always the same as the length of the first--- list.-zipWithLazy :: (a -> b -> c) -> [a] -> [b] -> [c]-zipWithLazy _ []     _       = []-zipWithLazy f (a:as) ~(b:bs) = f a b : zipWithLazy f as bs---- | 'zipWith3Lazy' is like 'zipWith3' but is lazy in the second and third lists.--- The length of the output is always the same as the length of the first--- list.-zipWith3Lazy :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]-zipWith3Lazy _ []     _       _       = []-zipWith3Lazy f (a:as) ~(b:bs) ~(c:cs) = f a b c : zipWith3Lazy f as bs cs---- | 'filterByList' takes a list of Bools and a list of some elements and--- filters out these elements for which the corresponding value in the list of--- Bools is False. This function does not check whether the lists have equal--- length.-filterByList :: [Bool] -> [a] -> [a]-filterByList (True:bs)  (x:xs) = x : filterByList bs xs-filterByList (False:bs) (_:xs) =     filterByList bs xs-filterByList _          _      = []---- | 'filterByLists' takes a list of Bools and two lists as input, and--- outputs a new list consisting of elements from the last two input lists. For--- each Bool in the list, if it is 'True', then it takes an element from the--- former list. If it is 'False', it takes an element from the latter list.--- The elements taken correspond to the index of the Bool in its list.--- For example:------ @--- filterByLists [True, False, True, False] \"abcd\" \"wxyz\" = \"axcz\"--- @------ This function does not check whether the lists have equal length.-filterByLists :: [Bool] -> [a] -> [a] -> [a]-filterByLists (True:bs)  (x:xs) (_:ys) = x : filterByLists bs xs ys-filterByLists (False:bs) (_:xs) (y:ys) = y : filterByLists bs xs ys-filterByLists _          _      _      = []---- | 'partitionByList' takes a list of Bools and a list of some elements and--- partitions the list according to the list of Bools. Elements corresponding--- to 'True' go to the left; elements corresponding to 'False' go to the right.--- For example, @partitionByList [True, False, True] [1,2,3] == ([1,3], [2])@--- This function does not check whether the lists have equal--- length; when one list runs out, the function stops.-partitionByList :: [Bool] -> [a] -> ([a], [a])-partitionByList = go [] []-  where-    go trues falses (True  : bs) (x : xs) = go (x:trues) falses bs xs-    go trues falses (False : bs) (x : xs) = go trues (x:falses) bs xs-    go trues falses _ _ = (reverse trues, reverse falses)--stretchZipWith :: (a -> Bool) -> b -> (a->b->c) -> [a] -> [b] -> [c]--- ^ @stretchZipWith p z f xs ys@ stretches @ys@ by inserting @z@ in--- the places where @p@ returns @True@--stretchZipWith _ _ _ []     _ = []-stretchZipWith p z f (x:xs) ys-  | p x       = f x z : stretchZipWith p z f xs ys-  | otherwise = case ys of-                []     -> []-                (y:ys) -> f x y : stretchZipWith p z f xs ys--mapFst :: (a->c) -> [(a,b)] -> [(c,b)]-mapSnd :: (b->c) -> [(a,b)] -> [(a,c)]--mapFst f xys = [(f x, y) | (x,y) <- xys]-mapSnd f xys = [(x, f y) | (x,y) <- xys]--mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])--mapAndUnzip _ [] = ([], [])-mapAndUnzip f (x:xs)-  = let (r1,  r2)  = f x-        (rs1, rs2) = mapAndUnzip f xs-    in-    (r1:rs1, r2:rs2)--mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])--mapAndUnzip3 _ [] = ([], [], [])-mapAndUnzip3 f (x:xs)-  = let (r1,  r2,  r3)  = f x-        (rs1, rs2, rs3) = mapAndUnzip3 f xs-    in-    (r1:rs1, r2:rs2, r3:rs3)--zipWithAndUnzip :: (a -> b -> (c,d)) -> [a] -> [b] -> ([c],[d])-zipWithAndUnzip f (a:as) (b:bs)-  = let (r1,  r2)  = f a b-        (rs1, rs2) = zipWithAndUnzip f as bs-    in-    (r1:rs1, r2:rs2)-zipWithAndUnzip _ _ _ = ([],[])---- | This has the effect of making the two lists have equal length by dropping--- the tail of the longer one.-zipAndUnzip :: [a] -> [b] -> ([a],[b])-zipAndUnzip (a:as) (b:bs)-  = let (rs1, rs2) = zipAndUnzip as bs-    in-    (a:rs1, b:rs2)-zipAndUnzip _ _ = ([],[])--mapAccumL2 :: (s1 -> s2 -> a -> (s1, s2, b)) -> s1 -> s2 -> [a] -> (s1, s2, [b])-mapAccumL2 f s1 s2 xs = (s1', s2', ys)-  where ((s1', s2'), ys) = mapAccumL (\(s1, s2) x -> case f s1 s2 x of-                                                       (s1', s2', y) -> ((s1', s2'), y))-                                     (s1, s2) xs---- | @atLength atLen atEnd ls n@ unravels list @ls@ to position @n@. Precisely:------ @---  atLength atLenPred atEndPred ls n---   | n < 0         = atLenPred ls---   | length ls < n = atEndPred (n - length ls)---   | otherwise     = atLenPred (drop n ls)--- @-atLength :: ([a] -> b)   -- Called when length ls >= n, passed (drop n ls)-                         --    NB: arg passed to this function may be []-         -> b            -- Called when length ls <  n-         -> [a]-         -> Int-         -> b-atLength atLenPred atEnd ls0 n0-  | n0 < 0    = atLenPred ls0-  | otherwise = go n0 ls0-  where-    -- go's first arg n >= 0-    go 0 ls     = atLenPred ls-    go _ []     = atEnd           -- n > 0 here-    go n (_:xs) = go (n-1) xs---- Some special cases of atLength:---- | @(lengthExceeds xs n) = (length xs > n)@-lengthExceeds :: [a] -> Int -> Bool-lengthExceeds lst n-  | n < 0-  = True-  | otherwise-  = atLength notNull False lst n---- | @(lengthAtLeast xs n) = (length xs >= n)@-lengthAtLeast :: [a] -> Int -> Bool-lengthAtLeast = atLength (const True) False---- | @(lengthIs xs n) = (length xs == n)@-lengthIs :: [a] -> Int -> Bool-lengthIs lst n-  | n < 0-  = False-  | otherwise-  = atLength null False lst n---- | @(lengthIsNot xs n) = (length xs /= n)@-lengthIsNot :: [a] -> Int -> Bool-lengthIsNot lst n-  | n < 0 = True-  | otherwise = atLength notNull True lst n---- | @(lengthAtMost xs n) = (length xs <= n)@-lengthAtMost :: [a] -> Int -> Bool-lengthAtMost lst n-  | n < 0-  = False-  | otherwise-  = atLength null True lst n---- | @(lengthLessThan xs n) == (length xs < n)@-lengthLessThan :: [a] -> Int -> Bool-lengthLessThan = atLength (const False) True--listLengthCmp :: [a] -> Int -> Ordering-listLengthCmp = atLength atLen atEnd- where-  atEnd = LT    -- Not yet seen 'n' elts, so list length is < n.--  atLen []     = EQ-  atLen _      = GT--equalLength :: [a] -> [b] -> Bool--- ^ True if length xs == length ys-equalLength []     []     = True-equalLength (_:xs) (_:ys) = equalLength xs ys-equalLength _      _      = False--compareLength :: [a] -> [b] -> Ordering-compareLength []     []     = EQ-compareLength (_:xs) (_:ys) = compareLength xs ys-compareLength []     _      = LT-compareLength _      []     = GT--leLength :: [a] -> [b] -> Bool--- ^ True if length xs <= length ys-leLength xs ys = case compareLength xs ys of-                   LT -> True-                   EQ -> True-                   GT -> False--ltLength :: [a] -> [b] -> Bool--- ^ True if length xs < length ys-ltLength xs ys = case compareLength xs ys of-                   LT -> True-                   EQ -> False-                   GT -> False-------------------------------singleton :: a -> [a]-singleton x = [x]--isSingleton :: [a] -> Bool-isSingleton [_] = True-isSingleton _   = False--notNull :: [a] -> Bool-notNull [] = False-notNull _  = True--only :: [a] -> a-#if defined(DEBUG)-only [a] = a-#else-only (a:_) = a-#endif-only _ = panic "Util: only"---- Debugging/specialising versions of \tr{elem} and \tr{notElem}--# if !defined(DEBUG)-isIn, isn'tIn :: Eq a => String -> a -> [a] -> Bool-isIn    _msg x ys = x `elem` ys-isn'tIn _msg x ys = x `notElem` ys--# else /* DEBUG */-isIn, isn'tIn :: (HasDebugCallStack, Eq a) => String -> a -> [a] -> Bool-isIn msg x ys-  = elem100 0 x ys-  where-    elem100 :: Eq a => Int -> a -> [a] -> Bool-    elem100 _ _ [] = False-    elem100 i x (y:ys)-      | i > 100 = WARN(True, text ("Over-long elem in " ++ msg)) (x `elem` (y:ys))-      | otherwise = x == y || elem100 (i + 1) x ys--isn'tIn msg x ys-  = notElem100 0 x ys-  where-    notElem100 :: Eq a => Int -> a -> [a] -> Bool-    notElem100 _ _ [] =  True-    notElem100 i x (y:ys)-      | i > 100 = WARN(True, text ("Over-long notElem in " ++ msg)) (x `notElem` (y:ys))-      | otherwise = x /= y && notElem100 (i + 1) x ys-# endif /* DEBUG */----- | Split a list into chunks of /n/ elements-chunkList :: Int -> [a] -> [[a]]-chunkList _ [] = []-chunkList n xs = as : chunkList n bs where (as,bs) = splitAt n xs---- | Replace the last element of a list with another element.-changeLast :: [a] -> a -> [a]-changeLast []     _  = panic "changeLast"-changeLast [_]    x  = [x]-changeLast (x:xs) x' = x : changeLast xs x'--whenNonEmpty :: Applicative m => [a] -> (NonEmpty a -> m ()) -> m ()-whenNonEmpty []     _ = pure ()-whenNonEmpty (x:xs) f = f (x :| xs)--{--************************************************************************-*                                                                      *-\subsubsection{Sort utils}-*                                                                      *-************************************************************************--}--minWith :: Ord b => (a -> b) -> [a] -> a-minWith get_key xs = ASSERT( not (null xs) )-                     head (sortWith get_key xs)--nubSort :: Ord a => [a] -> [a]-nubSort = Set.toAscList . Set.fromList---- | Remove duplicates but keep elements in order.---   O(n * log n)-ordNub :: Ord a => [a] -> [a]-ordNub xs-  = go Set.empty xs-  where-    go _ [] = []-    go s (x:xs)-      | Set.member x s = go s xs-      | otherwise = x : go (Set.insert x s) xs---{--************************************************************************-*                                                                      *-\subsection[Utils-transitive-closure]{Transitive closure}-*                                                                      *-************************************************************************--This algorithm for transitive closure is straightforward, albeit quadratic.--}--transitiveClosure :: (a -> [a])         -- Successor function-                  -> (a -> a -> Bool)   -- Equality predicate-                  -> [a]-                  -> [a]                -- The transitive closure--transitiveClosure succ eq xs- = go [] xs- where-   go done []                      = done-   go done (x:xs) | x `is_in` done = go done xs-                  | otherwise      = go (x:done) (succ x ++ xs)--   _ `is_in` []                 = False-   x `is_in` (y:ys) | eq x y    = True-                    | otherwise = x `is_in` ys--{--************************************************************************-*                                                                      *-\subsection[Utils-accum]{Accumulating}-*                                                                      *-************************************************************************--A combination of foldl with zip.  It works with equal length lists.--}--foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc-foldl2 _ z [] [] = z-foldl2 k z (a:as) (b:bs) = foldl2 k (k z a b) as bs-foldl2 _ _ _      _      = panic "Util: foldl2"--all2 :: (a -> b -> Bool) -> [a] -> [b] -> Bool--- True if the lists are the same length, and--- all corresponding elements satisfy the predicate-all2 _ []     []     = True-all2 p (x:xs) (y:ys) = p x y && all2 p xs ys-all2 _ _      _      = False---- Count the number of times a predicate is true--count :: (a -> Bool) -> [a] -> Int-count p = go 0-  where go !n [] = n-        go !n (x:xs) | p x       = go (n+1) xs-                     | otherwise = go n xs--countWhile :: (a -> Bool) -> [a] -> Int--- Length of an /initial prefix/ of the list satisfying p-countWhile p = go 0-  where go !n (x:xs) | p x = go (n+1) xs-        go !n _            = n--{--@splitAt@, @take@, and @drop@ but with length of another-list giving the break-off point:--}--takeList :: [b] -> [a] -> [a]--- (takeList as bs) trims bs to the be same length--- as as, unless as is longer in which case it's a no-op-takeList [] _ = []-takeList (_:xs) ls =-   case ls of-     [] -> []-     (y:ys) -> y : takeList xs ys--dropList :: [b] -> [a] -> [a]-dropList [] xs    = xs-dropList _  xs@[] = xs-dropList (_:xs) (_:ys) = dropList xs ys---splitAtList :: [b] -> [a] -> ([a], [a])-splitAtList [] xs     = ([], xs)-splitAtList _ xs@[]   = (xs, xs)-splitAtList (_:xs) (y:ys) = (y:ys', ys'')-    where-      (ys', ys'') = splitAtList xs ys---- drop from the end of a list-dropTail :: Int -> [a] -> [a]--- Specification: dropTail n = reverse . drop n . reverse--- Better implemention due to Joachim Breitner--- http://www.joachim-breitner.de/blog/archives/600-On-taking-the-last-n-elements-of-a-list.html-dropTail n xs-  = go (drop n xs) xs-  where-    go (_:ys) (x:xs) = x : go ys xs-    go _      _      = []  -- Stop when ys runs out-                           -- It'll always run out before xs does---- dropWhile from the end of a list. This is similar to Data.List.dropWhileEnd,--- but is lazy in the elements and strict in the spine. For reasonably short lists,--- such as path names and typical lines of text, dropWhileEndLE is generally--- faster than dropWhileEnd. Its advantage is magnified when the predicate is--- expensive--using dropWhileEndLE isSpace to strip the space off a line of text--- is generally much faster than using dropWhileEnd isSpace for that purpose.--- Specification: dropWhileEndLE p = reverse . dropWhile p . reverse--- Pay attention to the short-circuit (&&)! The order of its arguments is the only--- difference between dropWhileEnd and dropWhileEndLE.-dropWhileEndLE :: (a -> Bool) -> [a] -> [a]-dropWhileEndLE p = foldr (\x r -> if null r && p x then [] else x:r) []---- | @spanEnd p l == reverse (span p (reverse l))@. The first list--- returns actually comes after the second list (when you look at the--- input list).-spanEnd :: (a -> Bool) -> [a] -> ([a], [a])-spanEnd p l = go l [] [] l-  where go yes _rev_yes rev_no [] = (yes, reverse rev_no)-        go yes rev_yes  rev_no (x:xs)-          | p x       = go yes (x : rev_yes) rev_no                  xs-          | otherwise = go xs  []            (x : rev_yes ++ rev_no) xs---- | Get the last two elements in a list. Partial!-{-# INLINE last2 #-}-last2 :: [a] -> (a,a)-last2 = foldl' (\(_,x2) x -> (x2,x)) (partialError,partialError)-  where-    partialError = panic "last2 - list length less than two"--lastMaybe :: [a] -> Maybe a-lastMaybe [] = Nothing-lastMaybe xs = Just $ last xs---- | Split a list into its last element and the initial part of the list.--- @snocView xs = Just (init xs, last xs)@ for non-empty lists.--- @snocView xs = Nothing@ otherwise.--- Unless both parts of the result are guaranteed to be used--- prefer separate calls to @last@ + @init@.--- If you are guaranteed to use both, this will--- be more efficient.-snocView :: [a] -> Maybe ([a],a)-snocView [] = Nothing-snocView xs-    | (xs,x) <- go xs-    = Just (xs,x)-  where-    go :: [a] -> ([a],a)-    go [x] = ([],x)-    go (x:xs)-        | !(xs',x') <- go xs-        = (x:xs', x')-    go [] = error "impossible"--split :: Char -> String -> [String]-split c s = case rest of-                []     -> [chunk]-                _:rest -> chunk : split c rest-  where (chunk, rest) = break (==c) s---- | Convert a word to title case by capitalising the first letter-capitalise :: String -> String-capitalise [] = []-capitalise (c:cs) = toUpper c : cs---{--************************************************************************-*                                                                      *-\subsection[Utils-comparison]{Comparisons}-*                                                                      *-************************************************************************--}--isEqual :: Ordering -> Bool--- Often used in (isEqual (a `compare` b))-isEqual GT = False-isEqual EQ = True-isEqual LT = False--thenCmp :: Ordering -> Ordering -> Ordering-{-# INLINE thenCmp #-}-thenCmp EQ       ordering = ordering-thenCmp ordering _        = ordering--eqListBy :: (a->a->Bool) -> [a] -> [a] -> Bool-eqListBy _  []     []     = True-eqListBy eq (x:xs) (y:ys) = eq x y && eqListBy eq xs ys-eqListBy _  _      _      = False--eqMaybeBy :: (a ->a->Bool) -> Maybe a -> Maybe a -> Bool-eqMaybeBy _  Nothing  Nothing  = True-eqMaybeBy eq (Just x) (Just y) = eq x y-eqMaybeBy _  _        _        = False--cmpList :: (a -> a -> Ordering) -> [a] -> [a] -> Ordering-    -- `cmpList' uses a user-specified comparer--cmpList _   []     [] = EQ-cmpList _   []     _  = LT-cmpList _   _      [] = GT-cmpList cmp (a:as) (b:bs)-  = case cmp a b of { EQ -> cmpList cmp as bs; xxx -> xxx }--removeSpaces :: String -> String-removeSpaces = dropWhileEndLE isSpace . dropWhile isSpace---- Boolean operators lifted to Applicative-(<&&>) :: Applicative f => f Bool -> f Bool -> f Bool-(<&&>) = liftA2 (&&)-infixr 3 <&&> -- same as (&&)--(<||>) :: Applicative f => f Bool -> f Bool -> f Bool-(<||>) = liftA2 (||)-infixr 2 <||> -- same as (||)--{--************************************************************************-*                                                                      *-\subsection{Edit distance}-*                                                                      *-************************************************************************--}---- | Find the "restricted" Damerau-Levenshtein edit distance between two strings.--- See: <http://en.wikipedia.org/wiki/Damerau-Levenshtein_distance>.--- Based on the algorithm presented in "A Bit-Vector Algorithm for Computing--- Levenshtein and Damerau Edit Distances" in PSC'02 (Heikki Hyyro).--- See http://www.cs.uta.fi/~helmu/pubs/psc02.pdf and---     http://www.cs.uta.fi/~helmu/pubs/PSCerr.html for an explanation-restrictedDamerauLevenshteinDistance :: String -> String -> Int-restrictedDamerauLevenshteinDistance str1 str2-  = restrictedDamerauLevenshteinDistanceWithLengths m n str1 str2-  where-    m = length str1-    n = length str2--restrictedDamerauLevenshteinDistanceWithLengths-  :: Int -> Int -> String -> String -> Int-restrictedDamerauLevenshteinDistanceWithLengths m n str1 str2-  | m <= n-  = if n <= 32 -- n must be larger so this check is sufficient-    then restrictedDamerauLevenshteinDistance' (undefined :: Word32) m n str1 str2-    else restrictedDamerauLevenshteinDistance' (undefined :: Integer) m n str1 str2--  | otherwise-  = if m <= 32 -- m must be larger so this check is sufficient-    then restrictedDamerauLevenshteinDistance' (undefined :: Word32) n m str2 str1-    else restrictedDamerauLevenshteinDistance' (undefined :: Integer) n m str2 str1--restrictedDamerauLevenshteinDistance'-  :: (Bits bv, Num bv) => bv -> Int -> Int -> String -> String -> Int-restrictedDamerauLevenshteinDistance' _bv_dummy m n str1 str2-  | [] <- str1 = n-  | otherwise  = extractAnswer $-                 foldl' (restrictedDamerauLevenshteinDistanceWorker-                             (matchVectors str1) top_bit_mask vector_mask)-                        (0, 0, m_ones, 0, m) str2-  where-    m_ones@vector_mask = (2 ^ m) - 1-    top_bit_mask = (1 `shiftL` (m - 1)) `asTypeOf` _bv_dummy-    extractAnswer (_, _, _, _, distance) = distance--restrictedDamerauLevenshteinDistanceWorker-      :: (Bits bv, Num bv) => IM.IntMap bv -> bv -> bv-      -> (bv, bv, bv, bv, Int) -> Char -> (bv, bv, bv, bv, Int)-restrictedDamerauLevenshteinDistanceWorker str1_mvs top_bit_mask vector_mask-                                           (pm, d0, vp, vn, distance) char2-  = seq str1_mvs $ seq top_bit_mask $ seq vector_mask $-    seq pm' $ seq d0' $ seq vp' $ seq vn' $-    seq distance'' $ seq char2 $-    (pm', d0', vp', vn', distance'')-  where-    pm' = IM.findWithDefault 0 (ord char2) str1_mvs--    d0' = ((((sizedComplement vector_mask d0) .&. pm') `shiftL` 1) .&. pm)-      .|. ((((pm' .&. vp) + vp) .&. vector_mask) `xor` vp) .|. pm' .|. vn-          -- No need to mask the shiftL because of the restricted range of pm--    hp' = vn .|. sizedComplement vector_mask (d0' .|. vp)-    hn' = d0' .&. vp--    hp'_shift = ((hp' `shiftL` 1) .|. 1) .&. vector_mask-    hn'_shift = (hn' `shiftL` 1) .&. vector_mask-    vp' = hn'_shift .|. sizedComplement vector_mask (d0' .|. hp'_shift)-    vn' = d0' .&. hp'_shift--    distance' = if hp' .&. top_bit_mask /= 0 then distance + 1 else distance-    distance'' = if hn' .&. top_bit_mask /= 0 then distance' - 1 else distance'--sizedComplement :: Bits bv => bv -> bv -> bv-sizedComplement vector_mask vect = vector_mask `xor` vect--matchVectors :: (Bits bv, Num bv) => String -> IM.IntMap bv-matchVectors = snd . foldl' go (0 :: Int, IM.empty)-  where-    go (ix, im) char = let ix' = ix + 1-                           im' = IM.insertWith (.|.) (ord char) (2 ^ ix) im-                       in seq ix' $ seq im' $ (ix', im')--{-# SPECIALIZE INLINE restrictedDamerauLevenshteinDistance'-                      :: Word32 -> Int -> Int -> String -> String -> Int #-}-{-# SPECIALIZE INLINE restrictedDamerauLevenshteinDistance'-                      :: Integer -> Int -> Int -> String -> String -> Int #-}--{-# SPECIALIZE restrictedDamerauLevenshteinDistanceWorker-               :: IM.IntMap Word32 -> Word32 -> Word32-               -> (Word32, Word32, Word32, Word32, Int)-               -> Char -> (Word32, Word32, Word32, Word32, Int) #-}-{-# SPECIALIZE restrictedDamerauLevenshteinDistanceWorker-               :: IM.IntMap Integer -> Integer -> Integer-               -> (Integer, Integer, Integer, Integer, Int)-               -> Char -> (Integer, Integer, Integer, Integer, Int) #-}--{-# SPECIALIZE INLINE sizedComplement :: Word32 -> Word32 -> Word32 #-}-{-# SPECIALIZE INLINE sizedComplement :: Integer -> Integer -> Integer #-}--{-# SPECIALIZE matchVectors :: String -> IM.IntMap Word32 #-}-{-# SPECIALIZE matchVectors :: String -> IM.IntMap Integer #-}--fuzzyMatch :: String -> [String] -> [String]-fuzzyMatch key vals = fuzzyLookup key [(v,v) | v <- vals]---- | Search for possible matches to the users input in the given list,--- returning a small number of ranked results-fuzzyLookup :: String -> [(String,a)] -> [a]-fuzzyLookup user_entered possibilites-  = map fst $ take mAX_RESULTS $ sortBy (comparing snd)-    [ (poss_val, distance) | (poss_str, poss_val) <- possibilites-                       , let distance = restrictedDamerauLevenshteinDistance-                                            poss_str user_entered-                       , distance <= fuzzy_threshold ]-  where-    -- Work out an appropriate match threshold:-    -- We report a candidate if its edit distance is <= the threshold,-    -- The threshold is set to about a quarter of the # of characters the user entered-    --   Length    Threshold-    --     1         0          -- Don't suggest *any* candidates-    --     2         1          -- for single-char identifiers-    --     3         1-    --     4         1-    --     5         1-    --     6         2-    ---    fuzzy_threshold = truncate $ fromIntegral (length user_entered + 2) / (4 :: Rational)-    mAX_RESULTS = 3--{--************************************************************************-*                                                                      *-\subsection[Utils-pairs]{Pairs}-*                                                                      *-************************************************************************--}--unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]-unzipWith f pairs = map ( \ (a, b) -> f a b ) pairs--seqList :: [a] -> b -> b-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'--{--************************************************************************-*                                                                      *-                        Globals and the RTS-*                                                                      *-************************************************************************--When a plugin is loaded, it currently gets linked against a *newly-loaded* copy of the GHC package. This would not be a problem, except-that the new copy has its own mutable state that is not shared with-that state that has already been initialized by the original GHC-package.--(Note that if the GHC executable was dynamically linked this-wouldn't be a problem, because we could share the GHC library it-links to; this is only a problem if DYNAMIC_GHC_PROGRAMS=NO.)--The solution is to make use of @sharedCAF@ through @sharedGlobal@-for globals that are shared between multiple copies of ghc packages.--}---- Global variables:--global :: a -> IORef a-global a = unsafePerformIO (newIORef a)--consIORef :: IORef [a] -> a -> IO ()-consIORef var x = do-  atomicModifyIORef' var (\xs -> (x:xs,()))--globalM :: IO a -> IORef a-globalM ma = unsafePerformIO (ma >>= newIORef)---- Shared global variables:--sharedGlobal :: a -> (Ptr (IORef a) -> IO (Ptr (IORef a))) -> IORef a-sharedGlobal a get_or_set = unsafePerformIO $-  newIORef a >>= flip sharedCAF get_or_set--sharedGlobalM :: IO a -> (Ptr (IORef a) -> IO (Ptr (IORef a))) -> IORef a-sharedGlobalM ma get_or_set = unsafePerformIO $-  ma >>= newIORef >>= flip sharedCAF get_or_set---- Module names:--looksLikeModuleName :: String -> Bool-looksLikeModuleName [] = False-looksLikeModuleName (c:cs) = isUpper c && go cs-  where go [] = True-        go ('.':cs) = looksLikeModuleName cs-        go (c:cs)   = (isAlphaNum c || c == '_' || c == '\'') && go cs---- Similar to 'parse' for Distribution.Package.PackageName,--- but we don't want to depend on Cabal.-looksLikePackageName :: String -> Bool-looksLikePackageName = all (all isAlphaNum <&&> not . (all isDigit)) . split '-'--{--Akin to @Prelude.words@, but acts like the Bourne shell, treating-quoted strings as Haskell Strings, and also parses Haskell [String]-syntax.--}--getCmd :: String -> Either String             -- Error-                           (String, String) -- (Cmd, Rest)-getCmd s = case break isSpace $ dropWhile isSpace s of-           ([], _) -> Left ("Couldn't find command in " ++ show s)-           res -> Right res--toCmdArgs :: String -> Either String             -- Error-                              (String, [String]) -- (Cmd, Args)-toCmdArgs s = case getCmd s of-              Left err -> Left err-              Right (cmd, s') -> case toArgs s' of-                                 Left err -> Left err-                                 Right args -> Right (cmd, args)--toArgs :: String -> Either String   -- Error-                           [String] -- Args-toArgs str-    = case dropWhile isSpace str of-      s@('[':_) -> case reads s of-                   [(args, spaces)]-                    | all isSpace spaces ->-                       Right args-                   _ ->-                       Left ("Couldn't read " ++ show str ++ " as [String]")-      s -> toArgs' s- where-  toArgs' :: String -> Either String [String]-  -- Remove outer quotes:-  -- > toArgs' "\"foo\" \"bar baz\""-  -- Right ["foo", "bar baz"]-  ---  -- Keep inner quotes:-  -- > toArgs' "-DFOO=\"bar baz\""-  -- Right ["-DFOO=\"bar baz\""]-  toArgs' s = case dropWhile isSpace s of-              [] -> Right []-              ('"' : _) -> do-                    -- readAsString removes outer quotes-                    (arg, rest) <- readAsString s-                    (arg:) `fmap` toArgs' rest-              s' -> case break (isSpace <||> (== '"')) s' of-                    (argPart1, s''@('"':_)) -> do-                        (argPart2, rest) <- readAsString s''-                        -- show argPart2 to keep inner quotes-                        ((argPart1 ++ show argPart2):) `fmap` toArgs' rest-                    (arg, s'') -> (arg:) `fmap` toArgs' s''--  readAsString :: String -> Either String (String, String)-  readAsString s = case reads s of-                [(arg, rest)]-                    -- rest must either be [] or start with a space-                    | all isSpace (take 1 rest) ->-                    Right (arg, rest)-                _ ->-                    Left ("Couldn't read " ++ show s ++ " as String")--------------------------------------------------------------------------------- Integers---- | Determine the $\log_2$ of exact powers of 2-exactLog2 :: Integer -> Maybe Integer-exactLog2 x-   | x <= 0                               = Nothing-   | x > fromIntegral (maxBound :: Int32) = Nothing-   | x' .&. (-x') /= x'                   = Nothing-   | otherwise                            = Just (fromIntegral c)-      where-         x' = fromIntegral x :: Int32-         c = countTrailingZeros x'--{---- -------------------------------------------------------------------------------- Floats--}--readRational__ :: ReadS Rational -- NB: doesn't handle leading "-"-readRational__ r = do-     (n,d,s) <- readFix r-     (k,t)   <- readExp s-     return ((n%1)*10^^(k-d), t)- where-     readFix r = do-        (ds,s)  <- lexDecDigits r-        (ds',t) <- lexDotDigits s-        return (read (ds++ds'), length ds', t)--     readExp (e:s) | e `elem` "eE" = readExp' s-     readExp s                     = return (0,s)--     readExp' ('+':s) = readDec s-     readExp' ('-':s) = do (k,t) <- readDec s-                           return (-k,t)-     readExp' s       = readDec s--     readDec s = do-        (ds,r) <- nonnull isDigit s-        return (foldl1 (\n d -> n * 10 + d) [ ord d - ord '0' | d <- ds ],-                r)--     lexDecDigits = nonnull isDigit--     lexDotDigits ('.':s) = return (span' isDigit s)-     lexDotDigits s       = return ("",s)--     nonnull p s = do (cs@(_:_),t) <- return (span' p s)-                      return (cs,t)--     span' _ xs@[]         =  (xs, xs)-     span' p xs@(x:xs')-               | x == '_'  = span' p xs'   -- skip "_" (#14473)-               | p x       =  let (ys,zs) = span' p xs' in (x:ys,zs)-               | otherwise =  ([],xs)--readRational :: String -> Rational -- NB: *does* handle a leading "-"-readRational top_s-  = case top_s of-      '-' : xs -> - (read_me xs)-      xs       -> read_me xs-  where-    read_me s-      = case (do { (x,"") <- readRational__ s ; return x }) of-          [x] -> x-          []  -> error ("readRational: no parse:"        ++ top_s)-          _   -> error ("readRational: ambiguous parse:" ++ top_s)---readHexRational :: String -> Rational-readHexRational str =-  case str of-    '-' : xs -> - (readMe xs)-    xs       -> readMe xs-  where-  readMe as =-    case readHexRational__ as of-      Just n -> n-      _      -> error ("readHexRational: no parse:" ++ str)---readHexRational__ :: String -> Maybe Rational-readHexRational__ ('0' : x : rest)-  | x == 'X' || x == 'x' =-  do let (front,rest2) = span' isHexDigit rest-     guard (not (null front))-     let frontNum = steps 16 0 front-     case rest2 of-       '.' : rest3 ->-          do let (back,rest4) = span' isHexDigit rest3-             guard (not (null back))-             let backNum = steps 16 frontNum back-                 exp1    = -4 * length back-             case rest4 of-               p : ps | isExp p -> fmap (mk backNum . (+ exp1)) (getExp ps)-               _ -> return (mk backNum exp1)-       p : ps | isExp p -> fmap (mk frontNum) (getExp ps)-       _ -> Nothing--  where-  isExp p = p == 'p' || p == 'P'--  getExp ('+' : ds) = dec ds-  getExp ('-' : ds) = fmap negate (dec ds)-  getExp ds         = dec ds--  mk :: Integer -> Int -> Rational-  mk n e = fromInteger n * 2^^e--  dec cs = case span' isDigit cs of-             (ds,"") | not (null ds) -> Just (steps 10 0 ds)-             _ -> Nothing--  steps base n ds = foldl' (step base) n ds-  step  base n d  = base * n + fromIntegral (digitToInt d)--  span' _ xs@[]         =  (xs, xs)-  span' p xs@(x:xs')-            | x == '_'  = span' p xs'   -- skip "_"  (#14473)-            | p x       =  let (ys,zs) = span' p xs' in (x:ys,zs)-            | otherwise =  ([],xs)--readHexRational__ _ = Nothing---------------------------------------------------------------------------------- Verify that the 'dirname' portion of a FilePath exists.----doesDirNameExist :: FilePath -> IO Bool-doesDirNameExist fpath = doesDirectoryExist (takeDirectory fpath)---------------------------------------------------------------------------------- Backwards compatibility definition of getModificationTime--getModificationUTCTime :: FilePath -> IO UTCTime-getModificationUTCTime = getModificationTime---- ----------------------------------------------------------------- check existence & modification time at the same time--modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime)-modificationTimeIfExists f = do-  (do t <- getModificationUTCTime f; return (Just t))-        `catchIO` \e -> if isDoesNotExistError e-                        then return Nothing-                        else ioError e---- ----------------------------------------------------------------- atomic file writing by writing to a temporary file first (see #14533)------ This should be used in all cases where GHC writes files to disk--- and uses their modification time to skip work later,--- as otherwise a partially written file (e.g. due to crash or Ctrl+C)--- also results in a skip.--withAtomicRename :: (MonadIO m) => FilePath -> (FilePath -> m a) -> m a-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.-  -- This can still be fooled when somebody mounts a different file system-  -- at just the right time, but that is not a case we aim to cover here.-  let temp = targetFile <.> "tmp"-  res <- f temp-  liftIO $ renameFile temp targetFile-  return res---- ----------------------------------------------------------------- split a string at the last character where 'pred' is True,--- returning a pair of strings. The first component holds the string--- up (but not including) the last character for which 'pred' returned--- True, the second whatever comes after (but also not including the--- last character).------ If 'pred' returns False for all characters in the string, the original--- string is returned in the first component (and the second one is just--- empty).-splitLongestPrefix :: String -> (Char -> Bool) -> (String,String)-splitLongestPrefix str pred-  | null r_pre = (str,           [])-  | otherwise  = (reverse (tail r_pre), reverse r_suf)-                           -- 'tail' drops the char satisfying 'pred'-  where (r_suf, r_pre) = break pred (reverse str)--escapeSpaces :: String -> String-escapeSpaces = foldr (\c s -> if isSpace c then '\\':c:s else c:s) ""--type Suffix = String------------------------------------------------------------------- * Search path-----------------------------------------------------------------data Direction = Forwards | Backwards--reslash :: Direction -> FilePath -> FilePath-reslash d = f-    where f ('/'  : xs) = slash : f xs-          f ('\\' : xs) = slash : f xs-          f (x    : xs) = x     : f xs-          f ""          = ""-          slash = case d of-                  Forwards -> '/'-                  Backwards -> '\\'--makeRelativeTo :: FilePath -> FilePath -> FilePath-this `makeRelativeTo` that = directory </> thisFilename-    where (thisDirectory, thisFilename) = splitFileName this-          thatDirectory = dropFileName that-          directory = joinPath $ f (splitPath thisDirectory)-                                   (splitPath thatDirectory)--          f (x : xs) (y : ys)-           | x == y = f xs ys-          f xs ys = replicate (length ys) ".." ++ xs--{--************************************************************************-*                                                                      *-\subsection[Utils-Data]{Utils for defining Data instances}-*                                                                      *-************************************************************************--These functions helps us to define Data instances for abstract types.--}--abstractConstr :: String -> Constr-abstractConstr n = mkConstr (abstractDataType n) ("{abstract:"++n++"}") [] Prefix--abstractDataType :: String -> DataType-abstractDataType n = mkDataType n [abstractConstr n]--{--************************************************************************-*                                                                      *-\subsection[Utils-C]{Utils for printing C code}-*                                                                      *-************************************************************************--}--charToC :: Word8 -> String-charToC w =-  case chr (fromIntegral w) of-        '\"' -> "\\\""-        '\'' -> "\\\'"-        '\\' -> "\\\\"-        c | c >= ' ' && c <= '~' -> [c]-          | otherwise -> ['\\',-                         chr (ord '0' + ord c `div` 64),-                         chr (ord '0' + ord c `div` 8 `mod` 8),-                         chr (ord '0' + ord c         `mod` 8)]--{--************************************************************************-*                                                                      *-\subsection[Utils-Hashing]{Utils for hashing}-*                                                                      *-************************************************************************--}---- | A sample hash function for Strings.  We keep multiplying by the--- golden ratio and adding.  The implementation is:------ > hashString = foldl' f golden--- >   where f m c = fromIntegral (ord c) * magic + hashInt32 m--- >         magic = 0xdeadbeef------ Where hashInt32 works just as hashInt shown above.------ Knuth argues that repeated multiplication by the golden ratio--- will minimize gaps in the hash space, and thus it's a good choice--- for combining together multiple keys to form one.------ Here we know that individual characters c are often small, and this--- produces frequent collisions if we use ord c alone.  A--- particular problem are the shorter low ASCII and ISO-8859-1--- character strings.  We pre-multiply by a magic twiddle factor to--- obtain a good distribution.  In fact, given the following test:------ > testp :: Int32 -> Int--- > testp k = (n - ) . length . group . sort . map hs . take n $ ls--- >   where ls = [] : [c : l | l <- ls, c <- ['\0'..'\xff']]--- >         hs = foldl' f golden--- >         f m c = fromIntegral (ord c) * k + hashInt32 m--- >         n = 100000------ We discover that testp magic = 0.-hashString :: String -> Int32-hashString = foldl' f golden-   where f m c = fromIntegral (ord c) * magic + hashInt32 m-         magic = fromIntegral (0xdeadbeef :: Word32)--golden :: Int32-golden = 1013904242 -- = round ((sqrt 5 - 1) * 2^32) :: Int32--- was -1640531527 = round ((sqrt 5 - 1) * 2^31) :: Int32--- but that has bad mulHi properties (even adding 2^32 to get its inverse)--- Whereas the above works well and contains no hash duplications for--- [-32767..65536]---- | A sample (and useful) hash function for Int32,--- implemented by extracting the uppermost 32 bits of the 64-bit--- result of multiplying by a 33-bit constant.  The constant is from--- Knuth, derived from the golden ratio:------ > golden = round ((sqrt 5 - 1) * 2^32)------ We get good key uniqueness on small inputs--- (a problem with previous versions):---  (length $ group $ sort $ map hashInt32 [-32767..65536]) == 65536 + 32768----hashInt32 :: Int32 -> Int32-hashInt32 x = mulHi x golden + x---- hi 32 bits of a x-bit * 32 bit -> 64-bit multiply-mulHi :: Int32 -> Int32 -> Int32-mulHi a b = fromIntegral (r `shiftR` 32)-   where r :: Int64-         r = fromIntegral a * fromIntegral b---- | A call stack constraint, but only when 'isDebugOn'.-#if defined(DEBUG)-type HasDebugCallStack = HasCallStack-#else-type HasDebugCallStack = (() :: Constraint)-#endif--data OverridingBool-  = Auto-  | Always-  | Never-  deriving Show--overrideWith :: Bool -> OverridingBool -> Bool-overrideWith b Auto   = b-overrideWith _ Always = True-overrideWith _ Never  = False
ghc-lib-parser.cabal view
@@ -1,7 +1,7 @@ cabal-version: >=1.22 build-type: Simple name: ghc-lib-parser-version: 0.20200401+version: 0.20200501 license: BSD3 license-file: LICENSE category: Development@@ -40,17 +40,18 @@     ghc-lib/stage0/compiler/build/primop-vector-tys-exports.hs-incl     ghc-lib/stage0/compiler/build/primop-vector-tys.hs-incl     ghc-lib/stage0/compiler/build/primop-vector-uniques.hs-incl+    ghc-lib/stage0/compiler/build/primop-docs.hs-incl     ghc-lib/stage0/compiler/build/Config.hs     ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs-    ghc-lib/stage0/compiler/build/Parser.hs-    ghc-lib/stage0/compiler/build/Lexer.hs+    ghc-lib/stage0/compiler/build/GHC/Parser.hs+    ghc-lib/stage0/compiler/build/GHC/Parser/Lexer.hs     includes/ghcconfig.h     includes/MachDeps.h     includes/stg/MachRegs.h     includes/CodeGen.Platform.hs     compiler/HsVersions.h     compiler/Unique.h-tested-with: GHC==8.8.2, GHC==8.6.5, GHC==8.4.4+tested-with: GHC==8.10.1, GHC==8.8.2, GHC==8.6.5, GHC==8.4.4 source-repository head     type: git     location: git@github.com:digital-asset/ghc-lib.git@@ -72,8 +73,8 @@     else         build-depends: Win32     build-depends:-        ghc-prim > 0.2 && < 0.6,-        base >= 4.11 && < 4.14,+        ghc-prim > 0.2 && < 0.7,+        base >= 4.11 && < 4.15,         containers >= 0.5 && < 0.7,         bytestring >= 0.9 && < 0.11,         binary == 0.8.*,@@ -129,47 +130,22 @@         ghc-lib/stage0/compiler/build         libraries/template-haskell         libraries/ghc-boot-th-        compiler/typecheck         libraries/ghc-boot         libraries/ghc-heap-        compiler/prelude-        compiler/parser-        compiler/iface-        compiler/utils         libraries/ghci-        compiler/main         compiler/.         compiler     autogen-modules:-        Lexer-        Parser+        GHC.Parser.Lexer+        GHC.Parser     exposed-modules:-        ApiAnnotation-        Bag-        BinFingerprint-        Binary-        BooleanFormula-        BufWrite-        CliOption         Config-        Constants-        Constraint-        Ctype-        Digraph-        Encoding-        EnumSet-        ErrUtils-        Exception-        FV-        FastFunctions-        FastMutInt-        FastString-        FastStringEnv-        FileCleanup-        FileSettings-        Fingerprint-        FiniteMap         GHC.BaseDir+        GHC.Builtin.Names+        GHC.Builtin.PrimOps+        GHC.Builtin.Types+        GHC.Builtin.Types.Prim+        GHC.Builtin.Uniques         GHC.ByteCode.Types         GHC.Cmm         GHC.Cmm.BlockId@@ -183,6 +159,7 @@         GHC.Cmm.Node         GHC.Cmm.Switch         GHC.Cmm.Type+        GHC.CmmToAsm.Config         GHC.Core         GHC.Core.Arity         GHC.Core.Class@@ -196,14 +173,12 @@         GHC.Core.InstEnv         GHC.Core.Make         GHC.Core.Map-        GHC.Core.Op.ConstantFold-        GHC.Core.Op.Monad-        GHC.Core.Op.OccurAnal-        GHC.Core.Op.Tidy+        GHC.Core.Opt.ConstantFold+        GHC.Core.Opt.Monad+        GHC.Core.Opt.OccurAnal         GHC.Core.PatSyn         GHC.Core.Ppr         GHC.Core.Predicate-        GHC.Core.Rules         GHC.Core.Seq         GHC.Core.SimpleOpt         GHC.Core.Stats@@ -219,12 +194,27 @@         GHC.Core.Unify         GHC.Core.Utils         GHC.CoreToIface+        GHC.Data.Bag+        GHC.Data.BooleanFormula+        GHC.Data.EnumSet+        GHC.Data.FastMutInt+        GHC.Data.FastString+        GHC.Data.FastString.Env+        GHC.Data.FiniteMap+        GHC.Data.Graph.Directed+        GHC.Data.IOEnv+        GHC.Data.List.SetOps+        GHC.Data.Maybe+        GHC.Data.OrdList+        GHC.Data.Pair+        GHC.Data.Stream+        GHC.Data.StringBuffer+        GHC.Data.TrieMap         GHC.Driver.Backpack.Syntax         GHC.Driver.CmdLine         GHC.Driver.Flags         GHC.Driver.Hooks         GHC.Driver.Monad-        GHC.Driver.Packages         GHC.Driver.Phases         GHC.Driver.Pipeline.Monad         GHC.Driver.Plugins@@ -255,12 +245,19 @@         GHC.Hs.Types         GHC.Hs.Utils         GHC.HsToCore.PmCheck.Types+        GHC.Iface.Recomp.Binary         GHC.Iface.Syntax         GHC.Iface.Type         GHC.LanguageExtensions         GHC.LanguageExtensions.Type         GHC.Lexeme-        GHC.PackageDb+        GHC.Parser+        GHC.Parser.Annotation+        GHC.Parser.CharClass+        GHC.Parser.Header+        GHC.Parser.Lexer+        GHC.Parser.PostProcess+        GHC.Parser.PostProcess.Haddock         GHC.Platform         GHC.Platform.ARM         GHC.Platform.ARM64@@ -273,12 +270,24 @@         GHC.Platform.SPARC         GHC.Platform.X86         GHC.Platform.X86_64+        GHC.Prelude         GHC.Runtime.Eval.Types         GHC.Runtime.Heap.Layout         GHC.Runtime.Interpreter.Types         GHC.Runtime.Linker.Types         GHC.Serialized+        GHC.Settings+        GHC.Settings.Constants         GHC.Stg.Syntax+        GHC.SysTools.BaseDir+        GHC.SysTools.FileCleanup+        GHC.SysTools.Terminal+        GHC.Tc.Errors.Hole.FitTypes+        GHC.Tc.Types+        GHC.Tc.Types.Constraint+        GHC.Tc.Types.Evidence+        GHC.Tc.Types.Origin+        GHC.Tc.Utils.TcType         GHC.Types.Annotations         GHC.Types.Avail         GHC.Types.Basic@@ -292,7 +301,6 @@         GHC.Types.Id.Info         GHC.Types.Id.Make         GHC.Types.Literal-        GHC.Types.Module         GHC.Types.Name         GHC.Types.Name.Cache         GHC.Types.Name.Env@@ -311,20 +319,42 @@         GHC.Types.Var.Env         GHC.Types.Var.Set         GHC.UniqueSubdir+        GHC.Unit+        GHC.Unit.Database+        GHC.Unit.Info+        GHC.Unit.Module+        GHC.Unit.Module.Env+        GHC.Unit.Module.Location+        GHC.Unit.Module.Name+        GHC.Unit.Parser+        GHC.Unit.Ppr+        GHC.Unit.State+        GHC.Unit.Subst+        GHC.Unit.Types+        GHC.Utils.Binary+        GHC.Utils.BufHandle+        GHC.Utils.CliOption+        GHC.Utils.Encoding+        GHC.Utils.Error+        GHC.Utils.Exception+        GHC.Utils.FV+        GHC.Utils.Fingerprint+        GHC.Utils.IO.Unsafe+        GHC.Utils.Json         GHC.Utils.Lexeme+        GHC.Utils.Misc+        GHC.Utils.Monad+        GHC.Utils.Outputable+        GHC.Utils.Panic+        GHC.Utils.Panic.Plain+        GHC.Utils.Ppr+        GHC.Utils.Ppr.Colour         GHC.Version         GHCi.BreakArray         GHCi.FFI         GHCi.Message         GHCi.RemoteTypes         GHCi.TH.Binary-        GhcNameVersion-        GhcPrelude-        HaddockUtils-        HeaderInfo-        IOEnv-        Json-        KnownUniques         Language.Haskell.TH         Language.Haskell.TH.LanguageExtensions         Language.Haskell.TH.Lib@@ -333,36 +363,4 @@         Language.Haskell.TH.Ppr         Language.Haskell.TH.PprLib         Language.Haskell.TH.Syntax-        Lexer-        ListSetOps-        Maybes-        MonadUtils-        OrdList-        Outputable-        Pair-        Panic-        Parser-        PlainPanic-        PlatformConstants-        PprColour-        PrelNames-        Pretty-        PrimOp-        RdrHsSyn-        Settings         SizedSeq-        Stream-        StringBuffer-        SysTools.BaseDir-        SysTools.Terminal-        TcEvidence-        TcHoleFitTypes-        TcOrigin-        TcRnTypes-        TcType-        ToolSettings-        TrieMap-        TysPrim-        TysWiredIn-        UnitInfo-        Util
ghc-lib/stage0/compiler/build/Config.hs view
@@ -8,7 +8,7 @@   , cStage   ) where -import GhcPrelude+import GHC.Prelude  import GHC.Version
+ ghc-lib/stage0/compiler/build/GHC/Parser.hs view
@@ -0,0 +1,12970 @@+{-# OPTIONS_GHC -w #-}+{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}+#if __GLASGOW_HASKELL__ >= 710+{-# OPTIONS_GHC -XPartialTypeSignatures #-}+#endif+{-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE ScopedTypeVariables #-}++-- | This module provides the generated Happy parser for Haskell. It exports+-- a number of parsers which may be used in any library that uses the GHC API.+-- A common usage pattern is to initialize the parser state with a given string+-- and then parse that string:+--+-- @+--     runParser :: DynFlags -> String -> P a -> ParseResult a+--     runParser flags str parser = unP parser parseState+--     where+--       filename = "\<interactive\>"+--       location = mkRealSrcLoc (mkFastString filename) 1 1+--       buffer = stringToStringBuffer str+--       parseState = mkPState flags buffer location+-- @+module GHC.Parser+   ( parseModule, parseSignature, parseImport, parseStatement, parseBackpack+   , parseDeclaration, parseExpression, parsePattern+   , parseTypeSignature+   , parseStmt, parseIdentifier+   , parseType, parseHeader+   )+where++-- base+import Control.Monad    ( unless, liftM, when, (<=<) )+import GHC.Exts+import Data.Char+import Data.Maybe       ( maybeToList )+import Control.Monad    ( mplus )+import Control.Applicative ((<$))+import qualified Prelude++-- compiler+import GHC.Hs++import GHC.Driver.Phases  ( HscSource(..) )+import GHC.Driver.Types   ( IsBootInterface, WarningTxt(..) )+import GHC.Driver.Session+import GHC.Driver.Backpack.Syntax+import GHC.Unit.Info++-- compiler/utils+import GHC.Data.OrdList+import GHC.Data.BooleanFormula ( BooleanFormula(..), LBooleanFormula(..), mkTrue )+import GHC.Data.FastString+import GHC.Data.Maybe          ( isJust, orElse )+import GHC.Utils.Outputable+import GHC.Utils.Misc          ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )+import GHC.Prelude++-- compiler/basicTypes+import GHC.Types.Name.Reader+import GHC.Types.Name.Occurrence ( varName, dataName, tcClsName, tvName, startsWithUnderscore )+import GHC.Core.DataCon          ( DataCon, dataConName )+import GHC.Types.SrcLoc+import GHC.Unit.Module+import GHC.Types.Basic+import GHC.Types.ForeignCall++import GHC.Core.Type    ( funTyCon )+import GHC.Core.Class   ( FunDep )++-- compiler/parser+import GHC.Parser.PostProcess+import GHC.Parser.PostProcess.Haddock+import GHC.Parser.Lexer+import GHC.Parser.Annotation++import GHC.Tc.Types.Evidence  ( emptyTcEvBinds )++-- compiler/prelude+import GHC.Builtin.Types.Prim ( eqPrimTyCon )+import GHC.Builtin.Types ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,+                           unboxedUnitTyCon, unboxedUnitDataCon,+                           listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR )+import qualified Data.Array as Happy_Data_Array+import qualified Data.Bits as Bits+import qualified GHC.Exts as Happy_GHC_Exts+import Control.Applicative(Applicative(..))+import Control.Monad (ap)++-- parser produced by Happy Version 1.19.12++newtype HappyAbsSyn  = HappyAbsSyn HappyAny+#if __GLASGOW_HASKELL__ >= 607+type HappyAny = Happy_GHC_Exts.Any+#else+type HappyAny = forall a . a+#endif+newtype HappyWrap16 = HappyWrap16 (Located RdrName)+happyIn16 :: (Located RdrName) -> (HappyAbsSyn )+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap16 x)+{-# INLINE happyIn16 #-}+happyOut16 :: (HappyAbsSyn ) -> HappyWrap16+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut16 #-}+newtype HappyWrap17 = HappyWrap17 ([LHsUnit PackageName])+happyIn17 :: ([LHsUnit PackageName]) -> (HappyAbsSyn )+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap17 x)+{-# INLINE happyIn17 #-}+happyOut17 :: (HappyAbsSyn ) -> HappyWrap17+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut17 #-}+newtype HappyWrap18 = HappyWrap18 (OrdList (LHsUnit PackageName))+happyIn18 :: (OrdList (LHsUnit PackageName)) -> (HappyAbsSyn )+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap18 x)+{-# INLINE happyIn18 #-}+happyOut18 :: (HappyAbsSyn ) -> HappyWrap18+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut18 #-}+newtype HappyWrap19 = HappyWrap19 (LHsUnit PackageName)+happyIn19 :: (LHsUnit PackageName) -> (HappyAbsSyn )+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap19 x)+{-# INLINE happyIn19 #-}+happyOut19 :: (HappyAbsSyn ) -> HappyWrap19+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut19 #-}+newtype HappyWrap20 = HappyWrap20 (LHsUnitId PackageName)+happyIn20 :: (LHsUnitId PackageName) -> (HappyAbsSyn )+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap20 x)+{-# INLINE happyIn20 #-}+happyOut20 :: (HappyAbsSyn ) -> HappyWrap20+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut20 #-}+newtype HappyWrap21 = HappyWrap21 (OrdList (LHsModuleSubst PackageName))+happyIn21 :: (OrdList (LHsModuleSubst PackageName)) -> (HappyAbsSyn )+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap21 x)+{-# INLINE happyIn21 #-}+happyOut21 :: (HappyAbsSyn ) -> HappyWrap21+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut21 #-}+newtype HappyWrap22 = HappyWrap22 (LHsModuleSubst PackageName)+happyIn22 :: (LHsModuleSubst PackageName) -> (HappyAbsSyn )+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap22 x)+{-# INLINE happyIn22 #-}+happyOut22 :: (HappyAbsSyn ) -> HappyWrap22+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut22 #-}+newtype HappyWrap23 = HappyWrap23 (LHsModuleId PackageName)+happyIn23 :: (LHsModuleId PackageName) -> (HappyAbsSyn )+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap23 x)+{-# INLINE happyIn23 #-}+happyOut23 :: (HappyAbsSyn ) -> HappyWrap23+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut23 #-}+newtype HappyWrap24 = HappyWrap24 (Located PackageName)+happyIn24 :: (Located PackageName) -> (HappyAbsSyn )+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap24 x)+{-# INLINE happyIn24 #-}+happyOut24 :: (HappyAbsSyn ) -> HappyWrap24+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut24 #-}+newtype HappyWrap25 = HappyWrap25 (Located FastString)+happyIn25 :: (Located FastString) -> (HappyAbsSyn )+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap25 x)+{-# INLINE happyIn25 #-}+happyOut25 :: (HappyAbsSyn ) -> HappyWrap25+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut25 #-}+newtype HappyWrap26 = HappyWrap26 (Located FastString)+happyIn26 :: (Located FastString) -> (HappyAbsSyn )+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap26 x)+{-# INLINE happyIn26 #-}+happyOut26 :: (HappyAbsSyn ) -> HappyWrap26+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut26 #-}+newtype HappyWrap27 = HappyWrap27 (Maybe [LRenaming])+happyIn27 :: (Maybe [LRenaming]) -> (HappyAbsSyn )+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap27 x)+{-# INLINE happyIn27 #-}+happyOut27 :: (HappyAbsSyn ) -> HappyWrap27+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut27 #-}+newtype HappyWrap28 = HappyWrap28 (OrdList LRenaming)+happyIn28 :: (OrdList LRenaming) -> (HappyAbsSyn )+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap28 x)+{-# INLINE happyIn28 #-}+happyOut28 :: (HappyAbsSyn ) -> HappyWrap28+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut28 #-}+newtype HappyWrap29 = HappyWrap29 (LRenaming)+happyIn29 :: (LRenaming) -> (HappyAbsSyn )+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap29 x)+{-# INLINE happyIn29 #-}+happyOut29 :: (HappyAbsSyn ) -> HappyWrap29+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut29 #-}+newtype HappyWrap30 = HappyWrap30 (OrdList (LHsUnitDecl PackageName))+happyIn30 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap30 x)+{-# INLINE happyIn30 #-}+happyOut30 :: (HappyAbsSyn ) -> HappyWrap30+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut30 #-}+newtype HappyWrap31 = HappyWrap31 (OrdList (LHsUnitDecl PackageName))+happyIn31 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap31 x)+{-# INLINE happyIn31 #-}+happyOut31 :: (HappyAbsSyn ) -> HappyWrap31+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut31 #-}+newtype HappyWrap32 = HappyWrap32 (LHsUnitDecl PackageName)+happyIn32 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap32 x)+{-# INLINE happyIn32 #-}+happyOut32 :: (HappyAbsSyn ) -> HappyWrap32+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut32 #-}+newtype HappyWrap33 = HappyWrap33 (Located HsModule)+happyIn33 :: (Located HsModule) -> (HappyAbsSyn )+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap33 x)+{-# INLINE happyIn33 #-}+happyOut33 :: (HappyAbsSyn ) -> HappyWrap33+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut33 #-}+newtype HappyWrap34 = HappyWrap34 (Located HsModule)+happyIn34 :: (Located HsModule) -> (HappyAbsSyn )+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap34 x)+{-# INLINE happyIn34 #-}+happyOut34 :: (HappyAbsSyn ) -> HappyWrap34+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut34 #-}+newtype HappyWrap35 = HappyWrap35 (Maybe LHsDocString)+happyIn35 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap35 x)+{-# INLINE happyIn35 #-}+happyOut35 :: (HappyAbsSyn ) -> HappyWrap35+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut35 #-}+newtype HappyWrap36 = HappyWrap36 (())+happyIn36 :: (()) -> (HappyAbsSyn )+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap36 x)+{-# INLINE happyIn36 #-}+happyOut36 :: (HappyAbsSyn ) -> HappyWrap36+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut36 #-}+newtype HappyWrap37 = HappyWrap37 (())+happyIn37 :: (()) -> (HappyAbsSyn )+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap37 x)+{-# INLINE happyIn37 #-}+happyOut37 :: (HappyAbsSyn ) -> HappyWrap37+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut37 #-}+newtype HappyWrap38 = HappyWrap38 (Maybe (Located WarningTxt))+happyIn38 :: (Maybe (Located WarningTxt)) -> (HappyAbsSyn )+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap38 x)+{-# INLINE happyIn38 #-}+happyOut38 :: (HappyAbsSyn ) -> HappyWrap38+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut38 #-}+newtype HappyWrap39 = HappyWrap39 (([AddAnn]+             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))+happyIn39 :: (([AddAnn]+             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap39 x)+{-# INLINE happyIn39 #-}+happyOut39 :: (HappyAbsSyn ) -> HappyWrap39+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut39 #-}+newtype HappyWrap40 = HappyWrap40 (([AddAnn]+             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))+happyIn40 :: (([AddAnn]+             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap40 x)+{-# INLINE happyIn40 #-}+happyOut40 :: (HappyAbsSyn ) -> HappyWrap40+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut40 #-}+newtype HappyWrap41 = HappyWrap41 (([AddAnn]+             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))+happyIn41 :: (([AddAnn]+             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap41 x)+{-# INLINE happyIn41 #-}+happyOut41 :: (HappyAbsSyn ) -> HappyWrap41+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut41 #-}+newtype HappyWrap42 = HappyWrap42 (([LImportDecl GhcPs], [LHsDecl GhcPs]))+happyIn42 :: (([LImportDecl GhcPs], [LHsDecl GhcPs])) -> (HappyAbsSyn )+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap42 x)+{-# INLINE happyIn42 #-}+happyOut42 :: (HappyAbsSyn ) -> HappyWrap42+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut42 #-}+newtype HappyWrap43 = HappyWrap43 (Located HsModule)+happyIn43 :: (Located HsModule) -> (HappyAbsSyn )+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap43 x)+{-# INLINE happyIn43 #-}+happyOut43 :: (HappyAbsSyn ) -> HappyWrap43+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut43 #-}+newtype HappyWrap44 = HappyWrap44 ([LImportDecl GhcPs])+happyIn44 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap44 x)+{-# INLINE happyIn44 #-}+happyOut44 :: (HappyAbsSyn ) -> HappyWrap44+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut44 #-}+newtype HappyWrap45 = HappyWrap45 ([LImportDecl GhcPs])+happyIn45 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap45 x)+{-# INLINE happyIn45 #-}+happyOut45 :: (HappyAbsSyn ) -> HappyWrap45+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut45 #-}+newtype HappyWrap46 = HappyWrap46 ([LImportDecl GhcPs])+happyIn46 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap46 x)+{-# INLINE happyIn46 #-}+happyOut46 :: (HappyAbsSyn ) -> HappyWrap46+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut46 #-}+newtype HappyWrap47 = HappyWrap47 ([LImportDecl GhcPs])+happyIn47 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap47 x)+{-# INLINE happyIn47 #-}+happyOut47 :: (HappyAbsSyn ) -> HappyWrap47+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut47 #-}+newtype HappyWrap48 = HappyWrap48 ((Maybe (Located [LIE GhcPs])))+happyIn48 :: ((Maybe (Located [LIE GhcPs]))) -> (HappyAbsSyn )+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap48 x)+{-# INLINE happyIn48 #-}+happyOut48 :: (HappyAbsSyn ) -> HappyWrap48+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut48 #-}+newtype HappyWrap49 = HappyWrap49 (OrdList (LIE GhcPs))+happyIn49 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap49 x)+{-# INLINE happyIn49 #-}+happyOut49 :: (HappyAbsSyn ) -> HappyWrap49+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut49 #-}+newtype HappyWrap50 = HappyWrap50 (OrdList (LIE GhcPs))+happyIn50 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap50 x)+{-# INLINE happyIn50 #-}+happyOut50 :: (HappyAbsSyn ) -> HappyWrap50+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut50 #-}+newtype HappyWrap51 = HappyWrap51 (OrdList (LIE GhcPs))+happyIn51 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap51 x)+{-# INLINE happyIn51 #-}+happyOut51 :: (HappyAbsSyn ) -> HappyWrap51+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut51 #-}+newtype HappyWrap52 = HappyWrap52 (OrdList (LIE GhcPs))+happyIn52 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap52 x)+{-# INLINE happyIn52 #-}+happyOut52 :: (HappyAbsSyn ) -> HappyWrap52+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut52 #-}+newtype HappyWrap53 = HappyWrap53 (OrdList (LIE GhcPs))+happyIn53 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap53 x)+{-# INLINE happyIn53 #-}+happyOut53 :: (HappyAbsSyn ) -> HappyWrap53+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut53 #-}+newtype HappyWrap54 = HappyWrap54 (Located ([AddAnn],ImpExpSubSpec))+happyIn54 :: (Located ([AddAnn],ImpExpSubSpec)) -> (HappyAbsSyn )+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap54 x)+{-# INLINE happyIn54 #-}+happyOut54 :: (HappyAbsSyn ) -> HappyWrap54+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut54 #-}+newtype HappyWrap55 = HappyWrap55 (([AddAnn], [Located ImpExpQcSpec]))+happyIn55 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap55 x)+{-# INLINE happyIn55 #-}+happyOut55 :: (HappyAbsSyn ) -> HappyWrap55+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut55 #-}+newtype HappyWrap56 = HappyWrap56 (([AddAnn], [Located ImpExpQcSpec]))+happyIn56 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap56 x)+{-# INLINE happyIn56 #-}+happyOut56 :: (HappyAbsSyn ) -> HappyWrap56+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut56 #-}+newtype HappyWrap57 = HappyWrap57 (Located ([AddAnn], Located ImpExpQcSpec))+happyIn57 :: (Located ([AddAnn], Located ImpExpQcSpec)) -> (HappyAbsSyn )+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap57 x)+{-# INLINE happyIn57 #-}+happyOut57 :: (HappyAbsSyn ) -> HappyWrap57+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut57 #-}+newtype HappyWrap58 = HappyWrap58 (Located ImpExpQcSpec)+happyIn58 :: (Located ImpExpQcSpec) -> (HappyAbsSyn )+happyIn58 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap58 x)+{-# INLINE happyIn58 #-}+happyOut58 :: (HappyAbsSyn ) -> HappyWrap58+happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut58 #-}+newtype HappyWrap59 = HappyWrap59 (Located RdrName)+happyIn59 :: (Located RdrName) -> (HappyAbsSyn )+happyIn59 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap59 x)+{-# INLINE happyIn59 #-}+happyOut59 :: (HappyAbsSyn ) -> HappyWrap59+happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut59 #-}+newtype HappyWrap60 = HappyWrap60 ([AddAnn])+happyIn60 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn60 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap60 x)+{-# INLINE happyIn60 #-}+happyOut60 :: (HappyAbsSyn ) -> HappyWrap60+happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut60 #-}+newtype HappyWrap61 = HappyWrap61 ([AddAnn])+happyIn61 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn61 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap61 x)+{-# INLINE happyIn61 #-}+happyOut61 :: (HappyAbsSyn ) -> HappyWrap61+happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut61 #-}+newtype HappyWrap62 = HappyWrap62 ([LImportDecl GhcPs])+happyIn62 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn62 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap62 x)+{-# INLINE happyIn62 #-}+happyOut62 :: (HappyAbsSyn ) -> HappyWrap62+happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut62 #-}+newtype HappyWrap63 = HappyWrap63 ([LImportDecl GhcPs])+happyIn63 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )+happyIn63 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap63 x)+{-# INLINE happyIn63 #-}+happyOut63 :: (HappyAbsSyn ) -> HappyWrap63+happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut63 #-}+newtype HappyWrap64 = HappyWrap64 (LImportDecl GhcPs)+happyIn64 :: (LImportDecl GhcPs) -> (HappyAbsSyn )+happyIn64 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap64 x)+{-# INLINE happyIn64 #-}+happyOut64 :: (HappyAbsSyn ) -> HappyWrap64+happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut64 #-}+newtype HappyWrap65 = HappyWrap65 ((([AddAnn],SourceText),IsBootInterface))+happyIn65 :: ((([AddAnn],SourceText),IsBootInterface)) -> (HappyAbsSyn )+happyIn65 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap65 x)+{-# INLINE happyIn65 #-}+happyOut65 :: (HappyAbsSyn ) -> HappyWrap65+happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut65 #-}+newtype HappyWrap66 = HappyWrap66 (([AddAnn],Bool))+happyIn66 :: (([AddAnn],Bool)) -> (HappyAbsSyn )+happyIn66 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap66 x)+{-# INLINE happyIn66 #-}+happyOut66 :: (HappyAbsSyn ) -> HappyWrap66+happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut66 #-}+newtype HappyWrap67 = HappyWrap67 (([AddAnn],Maybe StringLiteral))+happyIn67 :: (([AddAnn],Maybe StringLiteral)) -> (HappyAbsSyn )+happyIn67 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap67 x)+{-# INLINE happyIn67 #-}+happyOut67 :: (HappyAbsSyn ) -> HappyWrap67+happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut67 #-}+newtype HappyWrap68 = HappyWrap68 (Maybe (Located Token))+happyIn68 :: (Maybe (Located Token)) -> (HappyAbsSyn )+happyIn68 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap68 x)+{-# INLINE happyIn68 #-}+happyOut68 :: (HappyAbsSyn ) -> HappyWrap68+happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut68 #-}+newtype HappyWrap69 = HappyWrap69 (([AddAnn],Located (Maybe (Located ModuleName))))+happyIn69 :: (([AddAnn],Located (Maybe (Located ModuleName)))) -> (HappyAbsSyn )+happyIn69 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap69 x)+{-# INLINE happyIn69 #-}+happyOut69 :: (HappyAbsSyn ) -> HappyWrap69+happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut69 #-}+newtype HappyWrap70 = HappyWrap70 (Located (Maybe (Bool, Located [LIE GhcPs])))+happyIn70 :: (Located (Maybe (Bool, Located [LIE GhcPs]))) -> (HappyAbsSyn )+happyIn70 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap70 x)+{-# INLINE happyIn70 #-}+happyOut70 :: (HappyAbsSyn ) -> HappyWrap70+happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut70 #-}+newtype HappyWrap71 = HappyWrap71 (Located (Bool, Located [LIE GhcPs]))+happyIn71 :: (Located (Bool, Located [LIE GhcPs])) -> (HappyAbsSyn )+happyIn71 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap71 x)+{-# INLINE happyIn71 #-}+happyOut71 :: (HappyAbsSyn ) -> HappyWrap71+happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut71 #-}+newtype HappyWrap72 = HappyWrap72 (Located (SourceText,Int))+happyIn72 :: (Located (SourceText,Int)) -> (HappyAbsSyn )+happyIn72 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap72 x)+{-# INLINE happyIn72 #-}+happyOut72 :: (HappyAbsSyn ) -> HappyWrap72+happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut72 #-}+newtype HappyWrap73 = HappyWrap73 (Located FixityDirection)+happyIn73 :: (Located FixityDirection) -> (HappyAbsSyn )+happyIn73 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap73 x)+{-# INLINE happyIn73 #-}+happyOut73 :: (HappyAbsSyn ) -> HappyWrap73+happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut73 #-}+newtype HappyWrap74 = HappyWrap74 (Located (OrdList (Located RdrName)))+happyIn74 :: (Located (OrdList (Located RdrName))) -> (HappyAbsSyn )+happyIn74 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap74 x)+{-# INLINE happyIn74 #-}+happyOut74 :: (HappyAbsSyn ) -> HappyWrap74+happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut74 #-}+newtype HappyWrap75 = HappyWrap75 (OrdList (LHsDecl GhcPs))+happyIn75 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )+happyIn75 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap75 x)+{-# INLINE happyIn75 #-}+happyOut75 :: (HappyAbsSyn ) -> HappyWrap75+happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut75 #-}+newtype HappyWrap76 = HappyWrap76 (OrdList (LHsDecl GhcPs))+happyIn76 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )+happyIn76 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap76 x)+{-# INLINE happyIn76 #-}+happyOut76 :: (HappyAbsSyn ) -> HappyWrap76+happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut76 #-}+newtype HappyWrap77 = HappyWrap77 (LHsDecl GhcPs)+happyIn77 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn77 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap77 x)+{-# INLINE happyIn77 #-}+happyOut77 :: (HappyAbsSyn ) -> HappyWrap77+happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut77 #-}+newtype HappyWrap78 = HappyWrap78 (LTyClDecl GhcPs)+happyIn78 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )+happyIn78 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap78 x)+{-# INLINE happyIn78 #-}+happyOut78 :: (HappyAbsSyn ) -> HappyWrap78+happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut78 #-}+newtype HappyWrap79 = HappyWrap79 (LTyClDecl GhcPs)+happyIn79 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )+happyIn79 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap79 x)+{-# INLINE happyIn79 #-}+happyOut79 :: (HappyAbsSyn ) -> HappyWrap79+happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut79 #-}+newtype HappyWrap80 = HappyWrap80 (LStandaloneKindSig GhcPs)+happyIn80 :: (LStandaloneKindSig GhcPs) -> (HappyAbsSyn )+happyIn80 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap80 x)+{-# INLINE happyIn80 #-}+happyOut80 :: (HappyAbsSyn ) -> HappyWrap80+happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut80 #-}+newtype HappyWrap81 = HappyWrap81 (Located [Located RdrName])+happyIn81 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn81 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap81 x)+{-# INLINE happyIn81 #-}+happyOut81 :: (HappyAbsSyn ) -> HappyWrap81+happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut81 #-}+newtype HappyWrap82 = HappyWrap82 (LInstDecl GhcPs)+happyIn82 :: (LInstDecl GhcPs) -> (HappyAbsSyn )+happyIn82 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap82 x)+{-# INLINE happyIn82 #-}+happyOut82 :: (HappyAbsSyn ) -> HappyWrap82+happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut82 #-}+newtype HappyWrap83 = HappyWrap83 (Maybe (Located OverlapMode))+happyIn83 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )+happyIn83 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap83 x)+{-# INLINE happyIn83 #-}+happyOut83 :: (HappyAbsSyn ) -> HappyWrap83+happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut83 #-}+newtype HappyWrap84 = HappyWrap84 (LDerivStrategy GhcPs)+happyIn84 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )+happyIn84 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap84 x)+{-# INLINE happyIn84 #-}+happyOut84 :: (HappyAbsSyn ) -> HappyWrap84+happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut84 #-}+newtype HappyWrap85 = HappyWrap85 (LDerivStrategy GhcPs)+happyIn85 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )+happyIn85 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap85 x)+{-# INLINE happyIn85 #-}+happyOut85 :: (HappyAbsSyn ) -> HappyWrap85+happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut85 #-}+newtype HappyWrap86 = HappyWrap86 (Maybe (LDerivStrategy GhcPs))+happyIn86 :: (Maybe (LDerivStrategy GhcPs)) -> (HappyAbsSyn )+happyIn86 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap86 x)+{-# INLINE happyIn86 #-}+happyOut86 :: (HappyAbsSyn ) -> HappyWrap86+happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut86 #-}+newtype HappyWrap87 = HappyWrap87 (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)))+happyIn87 :: (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )+happyIn87 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap87 x)+{-# INLINE happyIn87 #-}+happyOut87 :: (HappyAbsSyn ) -> HappyWrap87+happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut87 #-}+newtype HappyWrap88 = HappyWrap88 (LInjectivityAnn GhcPs)+happyIn88 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )+happyIn88 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap88 x)+{-# INLINE happyIn88 #-}+happyOut88 :: (HappyAbsSyn ) -> HappyWrap88+happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut88 #-}+newtype HappyWrap89 = HappyWrap89 (Located [Located RdrName])+happyIn89 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn89 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap89 x)+{-# INLINE happyIn89 #-}+happyOut89 :: (HappyAbsSyn ) -> HappyWrap89+happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut89 #-}+newtype HappyWrap90 = HappyWrap90 (Located ([AddAnn],FamilyInfo GhcPs))+happyIn90 :: (Located ([AddAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )+happyIn90 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap90 x)+{-# INLINE happyIn90 #-}+happyOut90 :: (HappyAbsSyn ) -> HappyWrap90+happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut90 #-}+newtype HappyWrap91 = HappyWrap91 (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]))+happyIn91 :: (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )+happyIn91 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap91 x)+{-# INLINE happyIn91 #-}+happyOut91 :: (HappyAbsSyn ) -> HappyWrap91+happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut91 #-}+newtype HappyWrap92 = HappyWrap92 (Located [LTyFamInstEqn GhcPs])+happyIn92 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )+happyIn92 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap92 x)+{-# INLINE happyIn92 #-}+happyOut92 :: (HappyAbsSyn ) -> HappyWrap92+happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut92 #-}+newtype HappyWrap93 = HappyWrap93 (Located ([AddAnn],TyFamInstEqn GhcPs))+happyIn93 :: (Located ([AddAnn],TyFamInstEqn GhcPs)) -> (HappyAbsSyn )+happyIn93 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap93 x)+{-# INLINE happyIn93 #-}+happyOut93 :: (HappyAbsSyn ) -> HappyWrap93+happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut93 #-}+newtype HappyWrap94 = HappyWrap94 (LHsDecl GhcPs)+happyIn94 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn94 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap94 x)+{-# INLINE happyIn94 #-}+happyOut94 :: (HappyAbsSyn ) -> HappyWrap94+happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut94 #-}+newtype HappyWrap95 = HappyWrap95 ([AddAnn])+happyIn95 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn95 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap95 x)+{-# INLINE happyIn95 #-}+happyOut95 :: (HappyAbsSyn ) -> HappyWrap95+happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut95 #-}+newtype HappyWrap96 = HappyWrap96 ([AddAnn])+happyIn96 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn96 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap96 x)+{-# INLINE happyIn96 #-}+happyOut96 :: (HappyAbsSyn ) -> HappyWrap96+happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut96 #-}+newtype HappyWrap97 = HappyWrap97 (LInstDecl GhcPs)+happyIn97 :: (LInstDecl GhcPs) -> (HappyAbsSyn )+happyIn97 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap97 x)+{-# INLINE happyIn97 #-}+happyOut97 :: (HappyAbsSyn ) -> HappyWrap97+happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut97 #-}+newtype HappyWrap98 = HappyWrap98 (Located (AddAnn, NewOrData))+happyIn98 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )+happyIn98 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap98 x)+{-# INLINE happyIn98 #-}+happyOut98 :: (HappyAbsSyn ) -> HappyWrap98+happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut98 #-}+newtype HappyWrap99 = HappyWrap99 (Located ([AddAnn], Maybe (LHsKind GhcPs)))+happyIn99 :: (Located ([AddAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )+happyIn99 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap99 x)+{-# INLINE happyIn99 #-}+happyOut99 :: (HappyAbsSyn ) -> HappyWrap99+happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut99 #-}+newtype HappyWrap100 = HappyWrap100 (Located ([AddAnn], LFamilyResultSig GhcPs))+happyIn100 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )+happyIn100 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap100 x)+{-# INLINE happyIn100 #-}+happyOut100 :: (HappyAbsSyn ) -> HappyWrap100+happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut100 #-}+newtype HappyWrap101 = HappyWrap101 (Located ([AddAnn], LFamilyResultSig GhcPs))+happyIn101 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )+happyIn101 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap101 x)+{-# INLINE happyIn101 #-}+happyOut101 :: (HappyAbsSyn ) -> HappyWrap101+happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut101 #-}+newtype HappyWrap102 = HappyWrap102 (Located ([AddAnn], ( LFamilyResultSig GhcPs+                                            , Maybe (LInjectivityAnn GhcPs))))+happyIn102 :: (Located ([AddAnn], ( LFamilyResultSig GhcPs+                                            , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )+happyIn102 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap102 x)+{-# INLINE happyIn102 #-}+happyOut102 :: (HappyAbsSyn ) -> HappyWrap102+happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut102 #-}+newtype HappyWrap103 = HappyWrap103 (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))+happyIn103 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )+happyIn103 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap103 x)+{-# INLINE happyIn103 #-}+happyOut103 :: (HappyAbsSyn ) -> HappyWrap103+happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut103 #-}+newtype HappyWrap104 = HappyWrap104 (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs)))+happyIn104 :: (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs))) -> (HappyAbsSyn )+happyIn104 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap104 x)+{-# INLINE happyIn104 #-}+happyOut104 :: (HappyAbsSyn ) -> HappyWrap104+happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut104 #-}+newtype HappyWrap105 = HappyWrap105 (Maybe (Located CType))+happyIn105 :: (Maybe (Located CType)) -> (HappyAbsSyn )+happyIn105 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap105 x)+{-# INLINE happyIn105 #-}+happyOut105 :: (HappyAbsSyn ) -> HappyWrap105+happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut105 #-}+newtype HappyWrap106 = HappyWrap106 (LDerivDecl GhcPs)+happyIn106 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )+happyIn106 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap106 x)+{-# INLINE happyIn106 #-}+happyOut106 :: (HappyAbsSyn ) -> HappyWrap106+happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut106 #-}+newtype HappyWrap107 = HappyWrap107 (LRoleAnnotDecl GhcPs)+happyIn107 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )+happyIn107 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap107 x)+{-# INLINE happyIn107 #-}+happyOut107 :: (HappyAbsSyn ) -> HappyWrap107+happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut107 #-}+newtype HappyWrap108 = HappyWrap108 (Located [Located (Maybe FastString)])+happyIn108 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )+happyIn108 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap108 x)+{-# INLINE happyIn108 #-}+happyOut108 :: (HappyAbsSyn ) -> HappyWrap108+happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut108 #-}+newtype HappyWrap109 = HappyWrap109 (Located [Located (Maybe FastString)])+happyIn109 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )+happyIn109 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap109 x)+{-# INLINE happyIn109 #-}+happyOut109 :: (HappyAbsSyn ) -> HappyWrap109+happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut109 #-}+newtype HappyWrap110 = HappyWrap110 (Located (Maybe FastString))+happyIn110 :: (Located (Maybe FastString)) -> (HappyAbsSyn )+happyIn110 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap110 x)+{-# INLINE happyIn110 #-}+happyOut110 :: (HappyAbsSyn ) -> HappyWrap110+happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut110 #-}+newtype HappyWrap111 = HappyWrap111 (LHsDecl GhcPs)+happyIn111 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn111 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap111 x)+{-# INLINE happyIn111 #-}+happyOut111 :: (HappyAbsSyn ) -> HappyWrap111+happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut111 #-}+newtype HappyWrap112 = HappyWrap112 ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))+happyIn112 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )+happyIn112 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap112 x)+{-# INLINE happyIn112 #-}+happyOut112 :: (HappyAbsSyn ) -> HappyWrap112+happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut112 #-}+newtype HappyWrap113 = HappyWrap113 ([Located RdrName])+happyIn113 :: ([Located RdrName]) -> (HappyAbsSyn )+happyIn113 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap113 x)+{-# INLINE happyIn113 #-}+happyOut113 :: (HappyAbsSyn ) -> HappyWrap113+happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut113 #-}+newtype HappyWrap114 = HappyWrap114 ([RecordPatSynField (Located RdrName)])+happyIn114 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )+happyIn114 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap114 x)+{-# INLINE happyIn114 #-}+happyOut114 :: (HappyAbsSyn ) -> HappyWrap114+happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut114 #-}+newtype HappyWrap115 = HappyWrap115 (Located ([AddAnn]+                         , Located (OrdList (LHsDecl GhcPs))))+happyIn115 :: (Located ([AddAnn]+                         , Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )+happyIn115 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap115 x)+{-# INLINE happyIn115 #-}+happyOut115 :: (HappyAbsSyn ) -> HappyWrap115+happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut115 #-}+newtype HappyWrap116 = HappyWrap116 (LSig GhcPs)+happyIn116 :: (LSig GhcPs) -> (HappyAbsSyn )+happyIn116 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap116 x)+{-# INLINE happyIn116 #-}+happyOut116 :: (HappyAbsSyn ) -> HappyWrap116+happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut116 #-}+newtype HappyWrap117 = HappyWrap117 (LHsDecl GhcPs)+happyIn117 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn117 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap117 x)+{-# INLINE happyIn117 #-}+happyOut117 :: (HappyAbsSyn ) -> HappyWrap117+happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut117 #-}+newtype HappyWrap118 = HappyWrap118 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))+happyIn118 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn118 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap118 x)+{-# INLINE happyIn118 #-}+happyOut118 :: (HappyAbsSyn ) -> HappyWrap118+happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut118 #-}+newtype HappyWrap119 = HappyWrap119 (Located ([AddAnn]+                     , OrdList (LHsDecl GhcPs)))+happyIn119 :: (Located ([AddAnn]+                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn119 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap119 x)+{-# INLINE happyIn119 #-}+happyOut119 :: (HappyAbsSyn ) -> HappyWrap119+happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut119 #-}+newtype HappyWrap120 = HappyWrap120 (Located ([AddAnn]+                       ,(OrdList (LHsDecl GhcPs))))+happyIn120 :: (Located ([AddAnn]+                       ,(OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )+happyIn120 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap120 x)+{-# INLINE happyIn120 #-}+happyOut120 :: (HappyAbsSyn ) -> HappyWrap120+happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut120 #-}+newtype HappyWrap121 = HappyWrap121 (Located (OrdList (LHsDecl GhcPs)))+happyIn121 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn121 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap121 x)+{-# INLINE happyIn121 #-}+happyOut121 :: (HappyAbsSyn ) -> HappyWrap121+happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut121 #-}+newtype HappyWrap122 = HappyWrap122 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))+happyIn122 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn122 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap122 x)+{-# INLINE happyIn122 #-}+happyOut122 :: (HappyAbsSyn ) -> HappyWrap122+happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut122 #-}+newtype HappyWrap123 = HappyWrap123 (Located ([AddAnn]+                     , OrdList (LHsDecl GhcPs)))+happyIn123 :: (Located ([AddAnn]+                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn123 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap123 x)+{-# INLINE happyIn123 #-}+happyOut123 :: (HappyAbsSyn ) -> HappyWrap123+happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut123 #-}+newtype HappyWrap124 = HappyWrap124 (Located ([AddAnn]+                        , OrdList (LHsDecl GhcPs)))+happyIn124 :: (Located ([AddAnn]+                        , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn124 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap124 x)+{-# INLINE happyIn124 #-}+happyOut124 :: (HappyAbsSyn ) -> HappyWrap124+happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut124 #-}+newtype HappyWrap125 = HappyWrap125 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))+happyIn125 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )+happyIn125 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap125 x)+{-# INLINE happyIn125 #-}+happyOut125 :: (HappyAbsSyn ) -> HappyWrap125+happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut125 #-}+newtype HappyWrap126 = HappyWrap126 (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))))+happyIn126 :: (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )+happyIn126 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap126 x)+{-# INLINE happyIn126 #-}+happyOut126 :: (HappyAbsSyn ) -> HappyWrap126+happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut126 #-}+newtype HappyWrap127 = HappyWrap127 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))+happyIn127 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )+happyIn127 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap127 x)+{-# INLINE happyIn127 #-}+happyOut127 :: (HappyAbsSyn ) -> HappyWrap127+happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut127 #-}+newtype HappyWrap128 = HappyWrap128 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))+happyIn128 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )+happyIn128 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap128 x)+{-# INLINE happyIn128 #-}+happyOut128 :: (HappyAbsSyn ) -> HappyWrap128+happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut128 #-}+newtype HappyWrap129 = HappyWrap129 (OrdList (LRuleDecl GhcPs))+happyIn129 :: (OrdList (LRuleDecl GhcPs)) -> (HappyAbsSyn )+happyIn129 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap129 x)+{-# INLINE happyIn129 #-}+happyOut129 :: (HappyAbsSyn ) -> HappyWrap129+happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut129 #-}+newtype HappyWrap130 = HappyWrap130 (LRuleDecl GhcPs)+happyIn130 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )+happyIn130 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap130 x)+{-# INLINE happyIn130 #-}+happyOut130 :: (HappyAbsSyn ) -> HappyWrap130+happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut130 #-}+newtype HappyWrap131 = HappyWrap131 (([AddAnn],Maybe Activation))+happyIn131 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )+happyIn131 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap131 x)+{-# INLINE happyIn131 #-}+happyOut131 :: (HappyAbsSyn ) -> HappyWrap131+happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut131 #-}+newtype HappyWrap132 = HappyWrap132 ([AddAnn])+happyIn132 :: ([AddAnn]) -> (HappyAbsSyn )+happyIn132 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap132 x)+{-# INLINE happyIn132 #-}+happyOut132 :: (HappyAbsSyn ) -> HappyWrap132+happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut132 #-}+newtype HappyWrap133 = HappyWrap133 (([AddAnn]+                              ,Activation))+happyIn133 :: (([AddAnn]+                              ,Activation)) -> (HappyAbsSyn )+happyIn133 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap133 x)+{-# INLINE happyIn133 #-}+happyOut133 :: (HappyAbsSyn ) -> HappyWrap133+happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut133 #-}+newtype HappyWrap134 = HappyWrap134 (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs]))+happyIn134 :: (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])) -> (HappyAbsSyn )+happyIn134 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap134 x)+{-# INLINE happyIn134 #-}+happyOut134 :: (HappyAbsSyn ) -> HappyWrap134+happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut134 #-}+newtype HappyWrap135 = HappyWrap135 ([LRuleTyTmVar])+happyIn135 :: ([LRuleTyTmVar]) -> (HappyAbsSyn )+happyIn135 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap135 x)+{-# INLINE happyIn135 #-}+happyOut135 :: (HappyAbsSyn ) -> HappyWrap135+happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut135 #-}+newtype HappyWrap136 = HappyWrap136 (LRuleTyTmVar)+happyIn136 :: (LRuleTyTmVar) -> (HappyAbsSyn )+happyIn136 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap136 x)+{-# INLINE happyIn136 #-}+happyOut136 :: (HappyAbsSyn ) -> HappyWrap136+happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut136 #-}+newtype HappyWrap137 = HappyWrap137 (OrdList (LWarnDecl GhcPs))+happyIn137 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn137 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap137 x)+{-# INLINE happyIn137 #-}+happyOut137 :: (HappyAbsSyn ) -> HappyWrap137+happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut137 #-}+newtype HappyWrap138 = HappyWrap138 (OrdList (LWarnDecl GhcPs))+happyIn138 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn138 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap138 x)+{-# INLINE happyIn138 #-}+happyOut138 :: (HappyAbsSyn ) -> HappyWrap138+happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut138 #-}+newtype HappyWrap139 = HappyWrap139 (OrdList (LWarnDecl GhcPs))+happyIn139 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn139 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap139 x)+{-# INLINE happyIn139 #-}+happyOut139 :: (HappyAbsSyn ) -> HappyWrap139+happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut139 #-}+newtype HappyWrap140 = HappyWrap140 (OrdList (LWarnDecl GhcPs))+happyIn140 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )+happyIn140 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap140 x)+{-# INLINE happyIn140 #-}+happyOut140 :: (HappyAbsSyn ) -> HappyWrap140+happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut140 #-}+newtype HappyWrap141 = HappyWrap141 (Located ([AddAnn],[Located StringLiteral]))+happyIn141 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )+happyIn141 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap141 x)+{-# INLINE happyIn141 #-}+happyOut141 :: (HappyAbsSyn ) -> HappyWrap141+happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut141 #-}+newtype HappyWrap142 = HappyWrap142 (Located (OrdList (Located StringLiteral)))+happyIn142 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )+happyIn142 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap142 x)+{-# INLINE happyIn142 #-}+happyOut142 :: (HappyAbsSyn ) -> HappyWrap142+happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut142 #-}+newtype HappyWrap143 = HappyWrap143 (LHsDecl GhcPs)+happyIn143 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn143 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap143 x)+{-# INLINE happyIn143 #-}+happyOut143 :: (HappyAbsSyn ) -> HappyWrap143+happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut143 #-}+newtype HappyWrap144 = HappyWrap144 (Located ([AddAnn],HsDecl GhcPs))+happyIn144 :: (Located ([AddAnn],HsDecl GhcPs)) -> (HappyAbsSyn )+happyIn144 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap144 x)+{-# INLINE happyIn144 #-}+happyOut144 :: (HappyAbsSyn ) -> HappyWrap144+happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut144 #-}+newtype HappyWrap145 = HappyWrap145 (Located CCallConv)+happyIn145 :: (Located CCallConv) -> (HappyAbsSyn )+happyIn145 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap145 x)+{-# INLINE happyIn145 #-}+happyOut145 :: (HappyAbsSyn ) -> HappyWrap145+happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut145 #-}+newtype HappyWrap146 = HappyWrap146 (Located Safety)+happyIn146 :: (Located Safety) -> (HappyAbsSyn )+happyIn146 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap146 x)+{-# INLINE happyIn146 #-}+happyOut146 :: (HappyAbsSyn ) -> HappyWrap146+happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut146 #-}+newtype HappyWrap147 = HappyWrap147 (Located ([AddAnn]+                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)))+happyIn147 :: (Located ([AddAnn]+                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )+happyIn147 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap147 x)+{-# INLINE happyIn147 #-}+happyOut147 :: (HappyAbsSyn ) -> HappyWrap147+happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut147 #-}+newtype HappyWrap148 = HappyWrap148 (([AddAnn], Maybe (LHsType GhcPs)))+happyIn148 :: (([AddAnn], Maybe (LHsType GhcPs))) -> (HappyAbsSyn )+happyIn148 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap148 x)+{-# INLINE happyIn148 #-}+happyOut148 :: (HappyAbsSyn ) -> HappyWrap148+happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut148 #-}+newtype HappyWrap149 = HappyWrap149 (([AddAnn], Maybe (Located RdrName)))+happyIn149 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )+happyIn149 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap149 x)+{-# INLINE happyIn149 #-}+happyOut149 :: (HappyAbsSyn ) -> HappyWrap149+happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut149 #-}+newtype HappyWrap150 = HappyWrap150 (LHsType GhcPs)+happyIn150 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn150 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap150 x)+{-# INLINE happyIn150 #-}+happyOut150 :: (HappyAbsSyn ) -> HappyWrap150+happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut150 #-}+newtype HappyWrap151 = HappyWrap151 (LHsType GhcPs)+happyIn151 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn151 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap151 x)+{-# INLINE happyIn151 #-}+happyOut151 :: (HappyAbsSyn ) -> HappyWrap151+happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut151 #-}+newtype HappyWrap152 = HappyWrap152 (Located [Located RdrName])+happyIn152 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn152 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap152 x)+{-# INLINE happyIn152 #-}+happyOut152 :: (HappyAbsSyn ) -> HappyWrap152+happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut152 #-}+newtype HappyWrap153 = HappyWrap153 ((OrdList (LHsSigType GhcPs)))+happyIn153 :: ((OrdList (LHsSigType GhcPs))) -> (HappyAbsSyn )+happyIn153 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap153 x)+{-# INLINE happyIn153 #-}+happyOut153 :: (HappyAbsSyn ) -> HappyWrap153+happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut153 #-}+newtype HappyWrap154 = HappyWrap154 (Located ([AddAnn], SourceText, SrcUnpackedness))+happyIn154 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )+happyIn154 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap154 x)+{-# INLINE happyIn154 #-}+happyOut154 :: (HappyAbsSyn ) -> HappyWrap154+happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut154 #-}+newtype HappyWrap155 = HappyWrap155 ((AddAnn, ForallVisFlag))+happyIn155 :: ((AddAnn, ForallVisFlag)) -> (HappyAbsSyn )+happyIn155 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap155 x)+{-# INLINE happyIn155 #-}+happyOut155 :: (HappyAbsSyn ) -> HappyWrap155+happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut155 #-}+newtype HappyWrap156 = HappyWrap156 (LHsType GhcPs)+happyIn156 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn156 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap156 x)+{-# INLINE happyIn156 #-}+happyOut156 :: (HappyAbsSyn ) -> HappyWrap156+happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut156 #-}+newtype HappyWrap157 = HappyWrap157 (LHsType GhcPs)+happyIn157 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn157 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap157 x)+{-# INLINE happyIn157 #-}+happyOut157 :: (HappyAbsSyn ) -> HappyWrap157+happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut157 #-}+newtype HappyWrap158 = HappyWrap158 (LHsType GhcPs)+happyIn158 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn158 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap158 x)+{-# INLINE happyIn158 #-}+happyOut158 :: (HappyAbsSyn ) -> HappyWrap158+happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut158 #-}+newtype HappyWrap159 = HappyWrap159 (LHsType GhcPs)+happyIn159 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn159 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap159 x)+{-# INLINE happyIn159 #-}+happyOut159 :: (HappyAbsSyn ) -> HappyWrap159+happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut159 #-}+newtype HappyWrap160 = HappyWrap160 (LHsContext GhcPs)+happyIn160 :: (LHsContext GhcPs) -> (HappyAbsSyn )+happyIn160 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap160 x)+{-# INLINE happyIn160 #-}+happyOut160 :: (HappyAbsSyn ) -> HappyWrap160+happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut160 #-}+newtype HappyWrap161 = HappyWrap161 (LHsContext GhcPs)+happyIn161 :: (LHsContext GhcPs) -> (HappyAbsSyn )+happyIn161 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap161 x)+{-# INLINE happyIn161 #-}+happyOut161 :: (HappyAbsSyn ) -> HappyWrap161+happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut161 #-}+newtype HappyWrap162 = HappyWrap162 (LHsType GhcPs)+happyIn162 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn162 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap162 x)+{-# INLINE happyIn162 #-}+happyOut162 :: (HappyAbsSyn ) -> HappyWrap162+happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut162 #-}+newtype HappyWrap163 = HappyWrap163 (LHsType GhcPs)+happyIn163 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn163 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap163 x)+{-# INLINE happyIn163 #-}+happyOut163 :: (HappyAbsSyn ) -> HappyWrap163+happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut163 #-}+newtype HappyWrap164 = HappyWrap164 (LHsType GhcPs)+happyIn164 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn164 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap164 x)+{-# INLINE happyIn164 #-}+happyOut164 :: (HappyAbsSyn ) -> HappyWrap164+happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut164 #-}+newtype HappyWrap165 = HappyWrap165 (Located [Located TyEl])+happyIn165 :: (Located [Located TyEl]) -> (HappyAbsSyn )+happyIn165 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap165 x)+{-# INLINE happyIn165 #-}+happyOut165 :: (HappyAbsSyn ) -> HappyWrap165+happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut165 #-}+newtype HappyWrap166 = HappyWrap166 (Located TyEl)+happyIn166 :: (Located TyEl) -> (HappyAbsSyn )+happyIn166 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap166 x)+{-# INLINE happyIn166 #-}+happyOut166 :: (HappyAbsSyn ) -> HappyWrap166+happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut166 #-}+newtype HappyWrap167 = HappyWrap167 (LHsType GhcPs)+happyIn167 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn167 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap167 x)+{-# INLINE happyIn167 #-}+happyOut167 :: (HappyAbsSyn ) -> HappyWrap167+happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut167 #-}+newtype HappyWrap168 = HappyWrap168 ([Located TyEl])+happyIn168 :: ([Located TyEl]) -> (HappyAbsSyn )+happyIn168 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap168 x)+{-# INLINE happyIn168 #-}+happyOut168 :: (HappyAbsSyn ) -> HappyWrap168+happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut168 #-}+newtype HappyWrap169 = HappyWrap169 (Located TyEl)+happyIn169 :: (Located TyEl) -> (HappyAbsSyn )+happyIn169 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap169 x)+{-# INLINE happyIn169 #-}+happyOut169 :: (HappyAbsSyn ) -> HappyWrap169+happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut169 #-}+newtype HappyWrap170 = HappyWrap170 (LHsType GhcPs)+happyIn170 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn170 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap170 x)+{-# INLINE happyIn170 #-}+happyOut170 :: (HappyAbsSyn ) -> HappyWrap170+happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut170 #-}+newtype HappyWrap171 = HappyWrap171 (LHsSigType GhcPs)+happyIn171 :: (LHsSigType GhcPs) -> (HappyAbsSyn )+happyIn171 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap171 x)+{-# INLINE happyIn171 #-}+happyOut171 :: (HappyAbsSyn ) -> HappyWrap171+happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut171 #-}+newtype HappyWrap172 = HappyWrap172 ([LHsSigType GhcPs])+happyIn172 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )+happyIn172 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap172 x)+{-# INLINE happyIn172 #-}+happyOut172 :: (HappyAbsSyn ) -> HappyWrap172+happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut172 #-}+newtype HappyWrap173 = HappyWrap173 ([LHsType GhcPs])+happyIn173 :: ([LHsType GhcPs]) -> (HappyAbsSyn )+happyIn173 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap173 x)+{-# INLINE happyIn173 #-}+happyOut173 :: (HappyAbsSyn ) -> HappyWrap173+happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut173 #-}+newtype HappyWrap174 = HappyWrap174 ([LHsType GhcPs])+happyIn174 :: ([LHsType GhcPs]) -> (HappyAbsSyn )+happyIn174 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap174 x)+{-# INLINE happyIn174 #-}+happyOut174 :: (HappyAbsSyn ) -> HappyWrap174+happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut174 #-}+newtype HappyWrap175 = HappyWrap175 ([LHsType GhcPs])+happyIn175 :: ([LHsType GhcPs]) -> (HappyAbsSyn )+happyIn175 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap175 x)+{-# INLINE happyIn175 #-}+happyOut175 :: (HappyAbsSyn ) -> HappyWrap175+happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut175 #-}+newtype HappyWrap176 = HappyWrap176 ([LHsTyVarBndr GhcPs])+happyIn176 :: ([LHsTyVarBndr GhcPs]) -> (HappyAbsSyn )+happyIn176 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap176 x)+{-# INLINE happyIn176 #-}+happyOut176 :: (HappyAbsSyn ) -> HappyWrap176+happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut176 #-}+newtype HappyWrap177 = HappyWrap177 (LHsTyVarBndr GhcPs)+happyIn177 :: (LHsTyVarBndr GhcPs) -> (HappyAbsSyn )+happyIn177 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap177 x)+{-# INLINE happyIn177 #-}+happyOut177 :: (HappyAbsSyn ) -> HappyWrap177+happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut177 #-}+newtype HappyWrap178 = HappyWrap178 (Located ([AddAnn],[Located (FunDep (Located RdrName))]))+happyIn178 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )+happyIn178 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap178 x)+{-# INLINE happyIn178 #-}+happyOut178 :: (HappyAbsSyn ) -> HappyWrap178+happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut178 #-}+newtype HappyWrap179 = HappyWrap179 (Located [Located (FunDep (Located RdrName))])+happyIn179 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )+happyIn179 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap179 x)+{-# INLINE happyIn179 #-}+happyOut179 :: (HappyAbsSyn ) -> HappyWrap179+happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut179 #-}+newtype HappyWrap180 = HappyWrap180 (Located (FunDep (Located RdrName)))+happyIn180 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )+happyIn180 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap180 x)+{-# INLINE happyIn180 #-}+happyOut180 :: (HappyAbsSyn ) -> HappyWrap180+happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut180 #-}+newtype HappyWrap181 = HappyWrap181 (Located [Located RdrName])+happyIn181 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn181 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap181 x)+{-# INLINE happyIn181 #-}+happyOut181 :: (HappyAbsSyn ) -> HappyWrap181+happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut181 #-}+newtype HappyWrap182 = HappyWrap182 (LHsKind GhcPs)+happyIn182 :: (LHsKind GhcPs) -> (HappyAbsSyn )+happyIn182 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap182 x)+{-# INLINE happyIn182 #-}+happyOut182 :: (HappyAbsSyn ) -> HappyWrap182+happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut182 #-}+newtype HappyWrap183 = HappyWrap183 (Located ([AddAnn]+                          ,[LConDecl GhcPs]))+happyIn183 :: (Located ([AddAnn]+                          ,[LConDecl GhcPs])) -> (HappyAbsSyn )+happyIn183 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap183 x)+{-# INLINE happyIn183 #-}+happyOut183 :: (HappyAbsSyn ) -> HappyWrap183+happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut183 #-}+newtype HappyWrap184 = HappyWrap184 (Located [LConDecl GhcPs])+happyIn184 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )+happyIn184 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap184 x)+{-# INLINE happyIn184 #-}+happyOut184 :: (HappyAbsSyn ) -> HappyWrap184+happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut184 #-}+newtype HappyWrap185 = HappyWrap185 (LConDecl GhcPs)+happyIn185 :: (LConDecl GhcPs) -> (HappyAbsSyn )+happyIn185 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap185 x)+{-# INLINE happyIn185 #-}+happyOut185 :: (HappyAbsSyn ) -> HappyWrap185+happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut185 #-}+newtype HappyWrap186 = HappyWrap186 (LConDecl GhcPs)+happyIn186 :: (LConDecl GhcPs) -> (HappyAbsSyn )+happyIn186 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap186 x)+{-# INLINE happyIn186 #-}+happyOut186 :: (HappyAbsSyn ) -> HappyWrap186+happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut186 #-}+newtype HappyWrap187 = HappyWrap187 (Located ([AddAnn],[LConDecl GhcPs]))+happyIn187 :: (Located ([AddAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )+happyIn187 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap187 x)+{-# INLINE happyIn187 #-}+happyOut187 :: (HappyAbsSyn ) -> HappyWrap187+happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut187 #-}+newtype HappyWrap188 = HappyWrap188 (Located [LConDecl GhcPs])+happyIn188 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )+happyIn188 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap188 x)+{-# INLINE happyIn188 #-}+happyOut188 :: (HappyAbsSyn ) -> HappyWrap188+happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut188 #-}+newtype HappyWrap189 = HappyWrap189 (LConDecl GhcPs)+happyIn189 :: (LConDecl GhcPs) -> (HappyAbsSyn )+happyIn189 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap189 x)+{-# INLINE happyIn189 #-}+happyOut189 :: (HappyAbsSyn ) -> HappyWrap189+happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut189 #-}+newtype HappyWrap190 = HappyWrap190 (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]))+happyIn190 :: (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])) -> (HappyAbsSyn )+happyIn190 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap190 x)+{-# INLINE happyIn190 #-}+happyOut190 :: (HappyAbsSyn ) -> HappyWrap190+happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut190 #-}+newtype HappyWrap191 = HappyWrap191 (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString))+happyIn191 :: (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)) -> (HappyAbsSyn )+happyIn191 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap191 x)+{-# INLINE happyIn191 #-}+happyOut191 :: (HappyAbsSyn ) -> HappyWrap191+happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut191 #-}+newtype HappyWrap192 = HappyWrap192 ([LConDeclField GhcPs])+happyIn192 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )+happyIn192 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap192 x)+{-# INLINE happyIn192 #-}+happyOut192 :: (HappyAbsSyn ) -> HappyWrap192+happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut192 #-}+newtype HappyWrap193 = HappyWrap193 ([LConDeclField GhcPs])+happyIn193 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )+happyIn193 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap193 x)+{-# INLINE happyIn193 #-}+happyOut193 :: (HappyAbsSyn ) -> HappyWrap193+happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut193 #-}+newtype HappyWrap194 = HappyWrap194 (LConDeclField GhcPs)+happyIn194 :: (LConDeclField GhcPs) -> (HappyAbsSyn )+happyIn194 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap194 x)+{-# INLINE happyIn194 #-}+happyOut194 :: (HappyAbsSyn ) -> HappyWrap194+happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut194 #-}+newtype HappyWrap195 = HappyWrap195 (HsDeriving GhcPs)+happyIn195 :: (HsDeriving GhcPs) -> (HappyAbsSyn )+happyIn195 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap195 x)+{-# INLINE happyIn195 #-}+happyOut195 :: (HappyAbsSyn ) -> HappyWrap195+happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut195 #-}+newtype HappyWrap196 = HappyWrap196 (HsDeriving GhcPs)+happyIn196 :: (HsDeriving GhcPs) -> (HappyAbsSyn )+happyIn196 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap196 x)+{-# INLINE happyIn196 #-}+happyOut196 :: (HappyAbsSyn ) -> HappyWrap196+happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut196 #-}+newtype HappyWrap197 = HappyWrap197 (LHsDerivingClause GhcPs)+happyIn197 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )+happyIn197 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap197 x)+{-# INLINE happyIn197 #-}+happyOut197 :: (HappyAbsSyn ) -> HappyWrap197+happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut197 #-}+newtype HappyWrap198 = HappyWrap198 (Located [LHsSigType GhcPs])+happyIn198 :: (Located [LHsSigType GhcPs]) -> (HappyAbsSyn )+happyIn198 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap198 x)+{-# INLINE happyIn198 #-}+happyOut198 :: (HappyAbsSyn ) -> HappyWrap198+happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut198 #-}+newtype HappyWrap199 = HappyWrap199 (LHsDecl GhcPs)+happyIn199 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn199 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap199 x)+{-# INLINE happyIn199 #-}+happyOut199 :: (HappyAbsSyn ) -> HappyWrap199+happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut199 #-}+newtype HappyWrap200 = HappyWrap200 (LDocDecl)+happyIn200 :: (LDocDecl) -> (HappyAbsSyn )+happyIn200 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap200 x)+{-# INLINE happyIn200 #-}+happyOut200 :: (HappyAbsSyn ) -> HappyWrap200+happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut200 #-}+newtype HappyWrap201 = HappyWrap201 (LHsDecl GhcPs)+happyIn201 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn201 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap201 x)+{-# INLINE happyIn201 #-}+happyOut201 :: (HappyAbsSyn ) -> HappyWrap201+happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut201 #-}+newtype HappyWrap202 = HappyWrap202 (LHsDecl GhcPs)+happyIn202 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn202 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap202 x)+{-# INLINE happyIn202 #-}+happyOut202 :: (HappyAbsSyn ) -> HappyWrap202+happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut202 #-}+newtype HappyWrap203 = HappyWrap203 (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))+happyIn203 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn203 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap203 x)+{-# INLINE happyIn203 #-}+happyOut203 :: (HappyAbsSyn ) -> HappyWrap203+happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut203 #-}+newtype HappyWrap204 = HappyWrap204 (Located [LGRHS GhcPs (LHsExpr GhcPs)])+happyIn204 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn204 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap204 x)+{-# INLINE happyIn204 #-}+happyOut204 :: (HappyAbsSyn ) -> HappyWrap204+happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut204 #-}+newtype HappyWrap205 = HappyWrap205 (LGRHS GhcPs (LHsExpr GhcPs))+happyIn205 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn205 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap205 x)+{-# INLINE happyIn205 #-}+happyOut205 :: (HappyAbsSyn ) -> HappyWrap205+happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut205 #-}+newtype HappyWrap206 = HappyWrap206 (LHsDecl GhcPs)+happyIn206 :: (LHsDecl GhcPs) -> (HappyAbsSyn )+happyIn206 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap206 x)+{-# INLINE happyIn206 #-}+happyOut206 :: (HappyAbsSyn ) -> HappyWrap206+happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut206 #-}+newtype HappyWrap207 = HappyWrap207 (([AddAnn],Maybe Activation))+happyIn207 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )+happyIn207 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap207 x)+{-# INLINE happyIn207 #-}+happyOut207 :: (HappyAbsSyn ) -> HappyWrap207+happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut207 #-}+newtype HappyWrap208 = HappyWrap208 (([AddAnn],Activation))+happyIn208 :: (([AddAnn],Activation)) -> (HappyAbsSyn )+happyIn208 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap208 x)+{-# INLINE happyIn208 #-}+happyOut208 :: (HappyAbsSyn ) -> HappyWrap208+happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut208 #-}+newtype HappyWrap209 = HappyWrap209 (Located (HsSplice GhcPs))+happyIn209 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )+happyIn209 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap209 x)+{-# INLINE happyIn209 #-}+happyOut209 :: (HappyAbsSyn ) -> HappyWrap209+happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut209 #-}+newtype HappyWrap210 = HappyWrap210 (ECP)+happyIn210 :: (ECP) -> (HappyAbsSyn )+happyIn210 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap210 x)+{-# INLINE happyIn210 #-}+happyOut210 :: (HappyAbsSyn ) -> HappyWrap210+happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut210 #-}+newtype HappyWrap211 = HappyWrap211 (ECP)+happyIn211 :: (ECP) -> (HappyAbsSyn )+happyIn211 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap211 x)+{-# INLINE happyIn211 #-}+happyOut211 :: (HappyAbsSyn ) -> HappyWrap211+happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut211 #-}+newtype HappyWrap212 = HappyWrap212 (ECP)+happyIn212 :: (ECP) -> (HappyAbsSyn )+happyIn212 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap212 x)+{-# INLINE happyIn212 #-}+happyOut212 :: (HappyAbsSyn ) -> HappyWrap212+happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut212 #-}+newtype HappyWrap213 = HappyWrap213 (ECP)+happyIn213 :: (ECP) -> (HappyAbsSyn )+happyIn213 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap213 x)+{-# INLINE happyIn213 #-}+happyOut213 :: (HappyAbsSyn ) -> HappyWrap213+happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut213 #-}+newtype HappyWrap214 = HappyWrap214 (([Located Token],Bool))+happyIn214 :: (([Located Token],Bool)) -> (HappyAbsSyn )+happyIn214 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap214 x)+{-# INLINE happyIn214 #-}+happyOut214 :: (HappyAbsSyn ) -> HappyWrap214+happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut214 #-}+newtype HappyWrap215 = HappyWrap215 (Located ([AddAnn], HsPragE GhcPs))+happyIn215 :: (Located ([AddAnn], HsPragE GhcPs)) -> (HappyAbsSyn )+happyIn215 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap215 x)+{-# INLINE happyIn215 #-}+happyOut215 :: (HappyAbsSyn ) -> HappyWrap215+happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut215 #-}+newtype HappyWrap216 = HappyWrap216 (ECP)+happyIn216 :: (ECP) -> (HappyAbsSyn )+happyIn216 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap216 x)+{-# INLINE happyIn216 #-}+happyOut216 :: (HappyAbsSyn ) -> HappyWrap216+happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut216 #-}+newtype HappyWrap217 = HappyWrap217 (ECP)+happyIn217 :: (ECP) -> (HappyAbsSyn )+happyIn217 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap217 x)+{-# INLINE happyIn217 #-}+happyOut217 :: (HappyAbsSyn ) -> HappyWrap217+happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut217 #-}+newtype HappyWrap218 = HappyWrap218 (ECP)+happyIn218 :: (ECP) -> (HappyAbsSyn )+happyIn218 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap218 x)+{-# INLINE happyIn218 #-}+happyOut218 :: (HappyAbsSyn ) -> HappyWrap218+happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut218 #-}+newtype HappyWrap219 = HappyWrap219 (ECP)+happyIn219 :: (ECP) -> (HappyAbsSyn )+happyIn219 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap219 x)+{-# INLINE happyIn219 #-}+happyOut219 :: (HappyAbsSyn ) -> HappyWrap219+happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut219 #-}+newtype HappyWrap220 = HappyWrap220 (LHsExpr GhcPs)+happyIn220 :: (LHsExpr GhcPs) -> (HappyAbsSyn )+happyIn220 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap220 x)+{-# INLINE happyIn220 #-}+happyOut220 :: (HappyAbsSyn ) -> HappyWrap220+happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut220 #-}+newtype HappyWrap221 = HappyWrap221 (Located (HsSplice GhcPs))+happyIn221 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )+happyIn221 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap221 x)+{-# INLINE happyIn221 #-}+happyOut221 :: (HappyAbsSyn ) -> HappyWrap221+happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut221 #-}+newtype HappyWrap222 = HappyWrap222 (Located (HsSplice GhcPs))+happyIn222 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )+happyIn222 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap222 x)+{-# INLINE happyIn222 #-}+happyOut222 :: (HappyAbsSyn ) -> HappyWrap222+happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut222 #-}+newtype HappyWrap223 = HappyWrap223 ([LHsCmdTop GhcPs])+happyIn223 :: ([LHsCmdTop GhcPs]) -> (HappyAbsSyn )+happyIn223 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap223 x)+{-# INLINE happyIn223 #-}+happyOut223 :: (HappyAbsSyn ) -> HappyWrap223+happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut223 #-}+newtype HappyWrap224 = HappyWrap224 (LHsCmdTop GhcPs)+happyIn224 :: (LHsCmdTop GhcPs) -> (HappyAbsSyn )+happyIn224 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap224 x)+{-# INLINE happyIn224 #-}+happyOut224 :: (HappyAbsSyn ) -> HappyWrap224+happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut224 #-}+newtype HappyWrap225 = HappyWrap225 (([AddAnn],[LHsDecl GhcPs]))+happyIn225 :: (([AddAnn],[LHsDecl GhcPs])) -> (HappyAbsSyn )+happyIn225 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap225 x)+{-# INLINE happyIn225 #-}+happyOut225 :: (HappyAbsSyn ) -> HappyWrap225+happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut225 #-}+newtype HappyWrap226 = HappyWrap226 ([LHsDecl GhcPs])+happyIn226 :: ([LHsDecl GhcPs]) -> (HappyAbsSyn )+happyIn226 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap226 x)+{-# INLINE happyIn226 #-}+happyOut226 :: (HappyAbsSyn ) -> HappyWrap226+happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut226 #-}+newtype HappyWrap227 = HappyWrap227 (ECP)+happyIn227 :: (ECP) -> (HappyAbsSyn )+happyIn227 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap227 x)+{-# INLINE happyIn227 #-}+happyOut227 :: (HappyAbsSyn ) -> HappyWrap227+happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut227 #-}+newtype HappyWrap228 = HappyWrap228 (forall b. DisambECP b => PV ([AddAnn],SumOrTuple b))+happyIn228 :: (forall b. DisambECP b => PV ([AddAnn],SumOrTuple b)) -> (HappyAbsSyn )+happyIn228 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap228 x)+{-# INLINE happyIn228 #-}+happyOut228 :: (HappyAbsSyn ) -> HappyWrap228+happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut228 #-}+newtype HappyWrap229 = HappyWrap229 (forall b. DisambECP b => PV (SrcSpan,[Located (Maybe (Located b))]))+happyIn229 :: (forall b. DisambECP b => PV (SrcSpan,[Located (Maybe (Located b))])) -> (HappyAbsSyn )+happyIn229 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap229 x)+{-# INLINE happyIn229 #-}+happyOut229 :: (HappyAbsSyn ) -> HappyWrap229+happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut229 #-}+newtype HappyWrap230 = HappyWrap230 (forall b. DisambECP b => PV [Located (Maybe (Located b))])+happyIn230 :: (forall b. DisambECP b => PV [Located (Maybe (Located b))]) -> (HappyAbsSyn )+happyIn230 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap230 x)+{-# INLINE happyIn230 #-}+happyOut230 :: (HappyAbsSyn ) -> HappyWrap230+happyOut230 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut230 #-}+newtype HappyWrap231 = HappyWrap231 (forall b. DisambECP b => SrcSpan -> PV (Located b))+happyIn231 :: (forall b. DisambECP b => SrcSpan -> PV (Located b)) -> (HappyAbsSyn )+happyIn231 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap231 x)+{-# INLINE happyIn231 #-}+happyOut231 :: (HappyAbsSyn ) -> HappyWrap231+happyOut231 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut231 #-}+newtype HappyWrap232 = HappyWrap232 (forall b. DisambECP b => PV [Located b])+happyIn232 :: (forall b. DisambECP b => PV [Located b]) -> (HappyAbsSyn )+happyIn232 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap232 x)+{-# INLINE happyIn232 #-}+happyOut232 :: (HappyAbsSyn ) -> HappyWrap232+happyOut232 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut232 #-}+newtype HappyWrap233 = HappyWrap233 (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyIn233 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn233 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap233 x)+{-# INLINE happyIn233 #-}+happyOut233 :: (HappyAbsSyn ) -> HappyWrap233+happyOut233 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut233 #-}+newtype HappyWrap234 = HappyWrap234 (Located [[LStmt GhcPs (LHsExpr GhcPs)]])+happyIn234 :: (Located [[LStmt GhcPs (LHsExpr GhcPs)]]) -> (HappyAbsSyn )+happyIn234 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap234 x)+{-# INLINE happyIn234 #-}+happyOut234 :: (HappyAbsSyn ) -> HappyWrap234+happyOut234 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut234 #-}+newtype HappyWrap235 = HappyWrap235 (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyIn235 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn235 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap235 x)+{-# INLINE happyIn235 #-}+happyOut235 :: (HappyAbsSyn ) -> HappyWrap235+happyOut235 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut235 #-}+newtype HappyWrap236 = HappyWrap236 (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)))+happyIn236 :: (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn236 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap236 x)+{-# INLINE happyIn236 #-}+happyOut236 :: (HappyAbsSyn ) -> HappyWrap236+happyOut236 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut236 #-}+newtype HappyWrap237 = HappyWrap237 (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyIn237 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn237 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap237 x)+{-# INLINE happyIn237 #-}+happyOut237 :: (HappyAbsSyn ) -> HappyWrap237+happyOut237 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut237 #-}+newtype HappyWrap238 = HappyWrap238 (Located [LStmt GhcPs (LHsExpr GhcPs)])+happyIn238 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )+happyIn238 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap238 x)+{-# INLINE happyIn238 #-}+happyOut238 :: (HappyAbsSyn ) -> HappyWrap238+happyOut238 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut238 #-}+newtype HappyWrap239 = HappyWrap239 (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])))+happyIn239 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)]))) -> (HappyAbsSyn )+happyIn239 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap239 x)+{-# INLINE happyIn239 #-}+happyOut239 :: (HappyAbsSyn ) -> HappyWrap239+happyOut239 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut239 #-}+newtype HappyWrap240 = HappyWrap240 (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])))+happyIn240 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)]))) -> (HappyAbsSyn )+happyIn240 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap240 x)+{-# INLINE happyIn240 #-}+happyOut240 :: (HappyAbsSyn ) -> HappyWrap240+happyOut240 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut240 #-}+newtype HappyWrap241 = HappyWrap241 (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])))+happyIn241 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)]))) -> (HappyAbsSyn )+happyIn241 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap241 x)+{-# INLINE happyIn241 #-}+happyOut241 :: (HappyAbsSyn ) -> HappyWrap241+happyOut241 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut241 #-}+newtype HappyWrap242 = HappyWrap242 (forall b. DisambECP b => PV (LMatch GhcPs (Located b)))+happyIn242 :: (forall b. DisambECP b => PV (LMatch GhcPs (Located b))) -> (HappyAbsSyn )+happyIn242 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap242 x)+{-# INLINE happyIn242 #-}+happyOut242 :: (HappyAbsSyn ) -> HappyWrap242+happyOut242 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut242 #-}+newtype HappyWrap243 = HappyWrap243 (forall b. DisambECP b => PV (Located ([AddAnn],GRHSs GhcPs (Located b))))+happyIn243 :: (forall b. DisambECP b => PV (Located ([AddAnn],GRHSs GhcPs (Located b)))) -> (HappyAbsSyn )+happyIn243 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap243 x)+{-# INLINE happyIn243 #-}+happyOut243 :: (HappyAbsSyn ) -> HappyWrap243+happyOut243 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut243 #-}+newtype HappyWrap244 = HappyWrap244 (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)]))+happyIn244 :: (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)])) -> (HappyAbsSyn )+happyIn244 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap244 x)+{-# INLINE happyIn244 #-}+happyOut244 :: (HappyAbsSyn ) -> HappyWrap244+happyOut244 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut244 #-}+newtype HappyWrap245 = HappyWrap245 (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)]))+happyIn245 :: (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)])) -> (HappyAbsSyn )+happyIn245 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap245 x)+{-# INLINE happyIn245 #-}+happyOut245 :: (HappyAbsSyn ) -> HappyWrap245+happyOut245 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut245 #-}+newtype HappyWrap246 = HappyWrap246 (Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)]))+happyIn246 :: (Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )+happyIn246 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap246 x)+{-# INLINE happyIn246 #-}+happyOut246 :: (HappyAbsSyn ) -> HappyWrap246+happyOut246 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut246 #-}+newtype HappyWrap247 = HappyWrap247 (forall b. DisambECP b => PV (LGRHS GhcPs (Located b)))+happyIn247 :: (forall b. DisambECP b => PV (LGRHS GhcPs (Located b))) -> (HappyAbsSyn )+happyIn247 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap247 x)+{-# INLINE happyIn247 #-}+happyOut247 :: (HappyAbsSyn ) -> HappyWrap247+happyOut247 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut247 #-}+newtype HappyWrap248 = HappyWrap248 (LPat GhcPs)+happyIn248 :: (LPat GhcPs) -> (HappyAbsSyn )+happyIn248 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap248 x)+{-# INLINE happyIn248 #-}+happyOut248 :: (HappyAbsSyn ) -> HappyWrap248+happyOut248 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut248 #-}+newtype HappyWrap249 = HappyWrap249 (LPat GhcPs)+happyIn249 :: (LPat GhcPs) -> (HappyAbsSyn )+happyIn249 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap249 x)+{-# INLINE happyIn249 #-}+happyOut249 :: (HappyAbsSyn ) -> HappyWrap249+happyOut249 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut249 #-}+newtype HappyWrap250 = HappyWrap250 (LPat GhcPs)+happyIn250 :: (LPat GhcPs) -> (HappyAbsSyn )+happyIn250 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap250 x)+{-# INLINE happyIn250 #-}+happyOut250 :: (HappyAbsSyn ) -> HappyWrap250+happyOut250 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut250 #-}+newtype HappyWrap251 = HappyWrap251 ([LPat GhcPs])+happyIn251 :: ([LPat GhcPs]) -> (HappyAbsSyn )+happyIn251 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap251 x)+{-# INLINE happyIn251 #-}+happyOut251 :: (HappyAbsSyn ) -> HappyWrap251+happyOut251 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut251 #-}+newtype HappyWrap252 = HappyWrap252 (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)])))+happyIn252 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)]))) -> (HappyAbsSyn )+happyIn252 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap252 x)+{-# INLINE happyIn252 #-}+happyOut252 :: (HappyAbsSyn ) -> HappyWrap252+happyOut252 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut252 #-}+newtype HappyWrap253 = HappyWrap253 (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)])))+happyIn253 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)]))) -> (HappyAbsSyn )+happyIn253 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap253 x)+{-# INLINE happyIn253 #-}+happyOut253 :: (HappyAbsSyn ) -> HappyWrap253+happyOut253 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut253 #-}+newtype HappyWrap254 = HappyWrap254 (Maybe (LStmt GhcPs (LHsExpr GhcPs)))+happyIn254 :: (Maybe (LStmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )+happyIn254 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap254 x)+{-# INLINE happyIn254 #-}+happyOut254 :: (HappyAbsSyn ) -> HappyWrap254+happyOut254 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut254 #-}+newtype HappyWrap255 = HappyWrap255 (LStmt GhcPs (LHsExpr GhcPs))+happyIn255 :: (LStmt GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )+happyIn255 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap255 x)+{-# INLINE happyIn255 #-}+happyOut255 :: (HappyAbsSyn ) -> HappyWrap255+happyOut255 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut255 #-}+newtype HappyWrap256 = HappyWrap256 (forall b. DisambECP b => PV (LStmt GhcPs (Located b)))+happyIn256 :: (forall b. DisambECP b => PV (LStmt GhcPs (Located b))) -> (HappyAbsSyn )+happyIn256 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap256 x)+{-# INLINE happyIn256 #-}+happyOut256 :: (HappyAbsSyn ) -> HappyWrap256+happyOut256 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut256 #-}+newtype HappyWrap257 = HappyWrap257 (forall b. DisambECP b => PV (LStmt GhcPs (Located b)))+happyIn257 :: (forall b. DisambECP b => PV (LStmt GhcPs (Located b))) -> (HappyAbsSyn )+happyIn257 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap257 x)+{-# INLINE happyIn257 #-}+happyOut257 :: (HappyAbsSyn ) -> HappyWrap257+happyOut257 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut257 #-}+newtype HappyWrap258 = HappyWrap258 (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan)))+happyIn258 :: (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan))) -> (HappyAbsSyn )+happyIn258 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap258 x)+{-# INLINE happyIn258 #-}+happyOut258 :: (HappyAbsSyn ) -> HappyWrap258+happyOut258 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut258 #-}+newtype HappyWrap259 = HappyWrap259 (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan)))+happyIn259 :: (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan))) -> (HappyAbsSyn )+happyIn259 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap259 x)+{-# INLINE happyIn259 #-}+happyOut259 :: (HappyAbsSyn ) -> HappyWrap259+happyOut259 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut259 #-}+newtype HappyWrap260 = HappyWrap260 (forall b. DisambECP b => PV (LHsRecField GhcPs (Located b)))+happyIn260 :: (forall b. DisambECP b => PV (LHsRecField GhcPs (Located b))) -> (HappyAbsSyn )+happyIn260 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap260 x)+{-# INLINE happyIn260 #-}+happyOut260 :: (HappyAbsSyn ) -> HappyWrap260+happyOut260 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut260 #-}+newtype HappyWrap261 = HappyWrap261 (Located [LIPBind GhcPs])+happyIn261 :: (Located [LIPBind GhcPs]) -> (HappyAbsSyn )+happyIn261 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap261 x)+{-# INLINE happyIn261 #-}+happyOut261 :: (HappyAbsSyn ) -> HappyWrap261+happyOut261 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut261 #-}+newtype HappyWrap262 = HappyWrap262 (LIPBind GhcPs)+happyIn262 :: (LIPBind GhcPs) -> (HappyAbsSyn )+happyIn262 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap262 x)+{-# INLINE happyIn262 #-}+happyOut262 :: (HappyAbsSyn ) -> HappyWrap262+happyOut262 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut262 #-}+newtype HappyWrap263 = HappyWrap263 (Located HsIPName)+happyIn263 :: (Located HsIPName) -> (HappyAbsSyn )+happyIn263 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap263 x)+{-# INLINE happyIn263 #-}+happyOut263 :: (HappyAbsSyn ) -> HappyWrap263+happyOut263 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut263 #-}+newtype HappyWrap264 = HappyWrap264 (Located FastString)+happyIn264 :: (Located FastString) -> (HappyAbsSyn )+happyIn264 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap264 x)+{-# INLINE happyIn264 #-}+happyOut264 :: (HappyAbsSyn ) -> HappyWrap264+happyOut264 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut264 #-}+newtype HappyWrap265 = HappyWrap265 (LBooleanFormula (Located RdrName))+happyIn265 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn265 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap265 x)+{-# INLINE happyIn265 #-}+happyOut265 :: (HappyAbsSyn ) -> HappyWrap265+happyOut265 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut265 #-}+newtype HappyWrap266 = HappyWrap266 (LBooleanFormula (Located RdrName))+happyIn266 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn266 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap266 x)+{-# INLINE happyIn266 #-}+happyOut266 :: (HappyAbsSyn ) -> HappyWrap266+happyOut266 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut266 #-}+newtype HappyWrap267 = HappyWrap267 (LBooleanFormula (Located RdrName))+happyIn267 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn267 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap267 x)+{-# INLINE happyIn267 #-}+happyOut267 :: (HappyAbsSyn ) -> HappyWrap267+happyOut267 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut267 #-}+newtype HappyWrap268 = HappyWrap268 ([LBooleanFormula (Located RdrName)])+happyIn268 :: ([LBooleanFormula (Located RdrName)]) -> (HappyAbsSyn )+happyIn268 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap268 x)+{-# INLINE happyIn268 #-}+happyOut268 :: (HappyAbsSyn ) -> HappyWrap268+happyOut268 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut268 #-}+newtype HappyWrap269 = HappyWrap269 (LBooleanFormula (Located RdrName))+happyIn269 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )+happyIn269 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap269 x)+{-# INLINE happyIn269 #-}+happyOut269 :: (HappyAbsSyn ) -> HappyWrap269+happyOut269 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut269 #-}+newtype HappyWrap270 = HappyWrap270 (Located [Located RdrName])+happyIn270 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn270 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap270 x)+{-# INLINE happyIn270 #-}+happyOut270 :: (HappyAbsSyn ) -> HappyWrap270+happyOut270 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut270 #-}+newtype HappyWrap271 = HappyWrap271 (Located RdrName)+happyIn271 :: (Located RdrName) -> (HappyAbsSyn )+happyIn271 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap271 x)+{-# INLINE happyIn271 #-}+happyOut271 :: (HappyAbsSyn ) -> HappyWrap271+happyOut271 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut271 #-}+newtype HappyWrap272 = HappyWrap272 (Located RdrName)+happyIn272 :: (Located RdrName) -> (HappyAbsSyn )+happyIn272 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap272 x)+{-# INLINE happyIn272 #-}+happyOut272 :: (HappyAbsSyn ) -> HappyWrap272+happyOut272 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut272 #-}+newtype HappyWrap273 = HappyWrap273 (Located RdrName)+happyIn273 :: (Located RdrName) -> (HappyAbsSyn )+happyIn273 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap273 x)+{-# INLINE happyIn273 #-}+happyOut273 :: (HappyAbsSyn ) -> HappyWrap273+happyOut273 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut273 #-}+newtype HappyWrap274 = HappyWrap274 (Located RdrName)+happyIn274 :: (Located RdrName) -> (HappyAbsSyn )+happyIn274 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap274 x)+{-# INLINE happyIn274 #-}+happyOut274 :: (HappyAbsSyn ) -> HappyWrap274+happyOut274 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut274 #-}+newtype HappyWrap275 = HappyWrap275 (Located RdrName)+happyIn275 :: (Located RdrName) -> (HappyAbsSyn )+happyIn275 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap275 x)+{-# INLINE happyIn275 #-}+happyOut275 :: (HappyAbsSyn ) -> HappyWrap275+happyOut275 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut275 #-}+newtype HappyWrap276 = HappyWrap276 (Located [Located RdrName])+happyIn276 :: (Located [Located RdrName]) -> (HappyAbsSyn )+happyIn276 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap276 x)+{-# INLINE happyIn276 #-}+happyOut276 :: (HappyAbsSyn ) -> HappyWrap276+happyOut276 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut276 #-}+newtype HappyWrap277 = HappyWrap277 (Located DataCon)+happyIn277 :: (Located DataCon) -> (HappyAbsSyn )+happyIn277 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap277 x)+{-# INLINE happyIn277 #-}+happyOut277 :: (HappyAbsSyn ) -> HappyWrap277+happyOut277 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut277 #-}+newtype HappyWrap278 = HappyWrap278 (Located DataCon)+happyIn278 :: (Located DataCon) -> (HappyAbsSyn )+happyIn278 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap278 x)+{-# INLINE happyIn278 #-}+happyOut278 :: (HappyAbsSyn ) -> HappyWrap278+happyOut278 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut278 #-}+newtype HappyWrap279 = HappyWrap279 (Located RdrName)+happyIn279 :: (Located RdrName) -> (HappyAbsSyn )+happyIn279 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap279 x)+{-# INLINE happyIn279 #-}+happyOut279 :: (HappyAbsSyn ) -> HappyWrap279+happyOut279 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut279 #-}+newtype HappyWrap280 = HappyWrap280 (Located RdrName)+happyIn280 :: (Located RdrName) -> (HappyAbsSyn )+happyIn280 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap280 x)+{-# INLINE happyIn280 #-}+happyOut280 :: (HappyAbsSyn ) -> HappyWrap280+happyOut280 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut280 #-}+newtype HappyWrap281 = HappyWrap281 (Located RdrName)+happyIn281 :: (Located RdrName) -> (HappyAbsSyn )+happyIn281 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap281 x)+{-# INLINE happyIn281 #-}+happyOut281 :: (HappyAbsSyn ) -> HappyWrap281+happyOut281 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut281 #-}+newtype HappyWrap282 = HappyWrap282 (Located RdrName)+happyIn282 :: (Located RdrName) -> (HappyAbsSyn )+happyIn282 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap282 x)+{-# INLINE happyIn282 #-}+happyOut282 :: (HappyAbsSyn ) -> HappyWrap282+happyOut282 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut282 #-}+newtype HappyWrap283 = HappyWrap283 (Located RdrName)+happyIn283 :: (Located RdrName) -> (HappyAbsSyn )+happyIn283 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap283 x)+{-# INLINE happyIn283 #-}+happyOut283 :: (HappyAbsSyn ) -> HappyWrap283+happyOut283 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut283 #-}+newtype HappyWrap284 = HappyWrap284 (Located RdrName)+happyIn284 :: (Located RdrName) -> (HappyAbsSyn )+happyIn284 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap284 x)+{-# INLINE happyIn284 #-}+happyOut284 :: (HappyAbsSyn ) -> HappyWrap284+happyOut284 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut284 #-}+newtype HappyWrap285 = HappyWrap285 (Located RdrName)+happyIn285 :: (Located RdrName) -> (HappyAbsSyn )+happyIn285 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap285 x)+{-# INLINE happyIn285 #-}+happyOut285 :: (HappyAbsSyn ) -> HappyWrap285+happyOut285 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut285 #-}+newtype HappyWrap286 = HappyWrap286 (Located RdrName)+happyIn286 :: (Located RdrName) -> (HappyAbsSyn )+happyIn286 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap286 x)+{-# INLINE happyIn286 #-}+happyOut286 :: (HappyAbsSyn ) -> HappyWrap286+happyOut286 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut286 #-}+newtype HappyWrap287 = HappyWrap287 (LHsType GhcPs)+happyIn287 :: (LHsType GhcPs) -> (HappyAbsSyn )+happyIn287 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap287 x)+{-# INLINE happyIn287 #-}+happyOut287 :: (HappyAbsSyn ) -> HappyWrap287+happyOut287 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut287 #-}+newtype HappyWrap288 = HappyWrap288 (Located RdrName)+happyIn288 :: (Located RdrName) -> (HappyAbsSyn )+happyIn288 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap288 x)+{-# INLINE happyIn288 #-}+happyOut288 :: (HappyAbsSyn ) -> HappyWrap288+happyOut288 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut288 #-}+newtype HappyWrap289 = HappyWrap289 (Located RdrName)+happyIn289 :: (Located RdrName) -> (HappyAbsSyn )+happyIn289 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap289 x)+{-# INLINE happyIn289 #-}+happyOut289 :: (HappyAbsSyn ) -> HappyWrap289+happyOut289 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut289 #-}+newtype HappyWrap290 = HappyWrap290 (Located RdrName)+happyIn290 :: (Located RdrName) -> (HappyAbsSyn )+happyIn290 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap290 x)+{-# INLINE happyIn290 #-}+happyOut290 :: (HappyAbsSyn ) -> HappyWrap290+happyOut290 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut290 #-}+newtype HappyWrap291 = HappyWrap291 (Located RdrName)+happyIn291 :: (Located RdrName) -> (HappyAbsSyn )+happyIn291 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap291 x)+{-# INLINE happyIn291 #-}+happyOut291 :: (HappyAbsSyn ) -> HappyWrap291+happyOut291 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut291 #-}+newtype HappyWrap292 = HappyWrap292 (Located RdrName)+happyIn292 :: (Located RdrName) -> (HappyAbsSyn )+happyIn292 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap292 x)+{-# INLINE happyIn292 #-}+happyOut292 :: (HappyAbsSyn ) -> HappyWrap292+happyOut292 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut292 #-}+newtype HappyWrap293 = HappyWrap293 (forall b. DisambInfixOp b => PV (Located b))+happyIn293 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )+happyIn293 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap293 x)+{-# INLINE happyIn293 #-}+happyOut293 :: (HappyAbsSyn ) -> HappyWrap293+happyOut293 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut293 #-}+newtype HappyWrap294 = HappyWrap294 (forall b. DisambInfixOp b => PV (Located b))+happyIn294 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )+happyIn294 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap294 x)+{-# INLINE happyIn294 #-}+happyOut294 :: (HappyAbsSyn ) -> HappyWrap294+happyOut294 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut294 #-}+newtype HappyWrap295 = HappyWrap295 (forall b. DisambInfixOp b => PV (Located b))+happyIn295 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )+happyIn295 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap295 x)+{-# INLINE happyIn295 #-}+happyOut295 :: (HappyAbsSyn ) -> HappyWrap295+happyOut295 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut295 #-}+newtype HappyWrap296 = HappyWrap296 (Located RdrName)+happyIn296 :: (Located RdrName) -> (HappyAbsSyn )+happyIn296 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap296 x)+{-# INLINE happyIn296 #-}+happyOut296 :: (HappyAbsSyn ) -> HappyWrap296+happyOut296 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut296 #-}+newtype HappyWrap297 = HappyWrap297 (Located RdrName)+happyIn297 :: (Located RdrName) -> (HappyAbsSyn )+happyIn297 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap297 x)+{-# INLINE happyIn297 #-}+happyOut297 :: (HappyAbsSyn ) -> HappyWrap297+happyOut297 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut297 #-}+newtype HappyWrap298 = HappyWrap298 (Located RdrName)+happyIn298 :: (Located RdrName) -> (HappyAbsSyn )+happyIn298 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap298 x)+{-# INLINE happyIn298 #-}+happyOut298 :: (HappyAbsSyn ) -> HappyWrap298+happyOut298 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut298 #-}+newtype HappyWrap299 = HappyWrap299 (Located RdrName)+happyIn299 :: (Located RdrName) -> (HappyAbsSyn )+happyIn299 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap299 x)+{-# INLINE happyIn299 #-}+happyOut299 :: (HappyAbsSyn ) -> HappyWrap299+happyOut299 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut299 #-}+newtype HappyWrap300 = HappyWrap300 (Located RdrName)+happyIn300 :: (Located RdrName) -> (HappyAbsSyn )+happyIn300 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap300 x)+{-# INLINE happyIn300 #-}+happyOut300 :: (HappyAbsSyn ) -> HappyWrap300+happyOut300 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut300 #-}+newtype HappyWrap301 = HappyWrap301 (Located RdrName)+happyIn301 :: (Located RdrName) -> (HappyAbsSyn )+happyIn301 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap301 x)+{-# INLINE happyIn301 #-}+happyOut301 :: (HappyAbsSyn ) -> HappyWrap301+happyOut301 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut301 #-}+newtype HappyWrap302 = HappyWrap302 (Located RdrName)+happyIn302 :: (Located RdrName) -> (HappyAbsSyn )+happyIn302 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap302 x)+{-# INLINE happyIn302 #-}+happyOut302 :: (HappyAbsSyn ) -> HappyWrap302+happyOut302 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut302 #-}+newtype HappyWrap303 = HappyWrap303 (Located RdrName)+happyIn303 :: (Located RdrName) -> (HappyAbsSyn )+happyIn303 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap303 x)+{-# INLINE happyIn303 #-}+happyOut303 :: (HappyAbsSyn ) -> HappyWrap303+happyOut303 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut303 #-}+newtype HappyWrap304 = HappyWrap304 (Located RdrName)+happyIn304 :: (Located RdrName) -> (HappyAbsSyn )+happyIn304 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap304 x)+{-# INLINE happyIn304 #-}+happyOut304 :: (HappyAbsSyn ) -> HappyWrap304+happyOut304 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut304 #-}+newtype HappyWrap305 = HappyWrap305 (Located RdrName)+happyIn305 :: (Located RdrName) -> (HappyAbsSyn )+happyIn305 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap305 x)+{-# INLINE happyIn305 #-}+happyOut305 :: (HappyAbsSyn ) -> HappyWrap305+happyOut305 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut305 #-}+newtype HappyWrap306 = HappyWrap306 (Located RdrName)+happyIn306 :: (Located RdrName) -> (HappyAbsSyn )+happyIn306 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap306 x)+{-# INLINE happyIn306 #-}+happyOut306 :: (HappyAbsSyn ) -> HappyWrap306+happyOut306 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut306 #-}+newtype HappyWrap307 = HappyWrap307 (Located RdrName)+happyIn307 :: (Located RdrName) -> (HappyAbsSyn )+happyIn307 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap307 x)+{-# INLINE happyIn307 #-}+happyOut307 :: (HappyAbsSyn ) -> HappyWrap307+happyOut307 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut307 #-}+newtype HappyWrap308 = HappyWrap308 (Located RdrName)+happyIn308 :: (Located RdrName) -> (HappyAbsSyn )+happyIn308 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap308 x)+{-# INLINE happyIn308 #-}+happyOut308 :: (HappyAbsSyn ) -> HappyWrap308+happyOut308 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut308 #-}+newtype HappyWrap309 = HappyWrap309 (Located RdrName)+happyIn309 :: (Located RdrName) -> (HappyAbsSyn )+happyIn309 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap309 x)+{-# INLINE happyIn309 #-}+happyOut309 :: (HappyAbsSyn ) -> HappyWrap309+happyOut309 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut309 #-}+newtype HappyWrap310 = HappyWrap310 (Located FastString)+happyIn310 :: (Located FastString) -> (HappyAbsSyn )+happyIn310 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap310 x)+{-# INLINE happyIn310 #-}+happyOut310 :: (HappyAbsSyn ) -> HappyWrap310+happyOut310 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut310 #-}+newtype HappyWrap311 = HappyWrap311 (Located FastString)+happyIn311 :: (Located FastString) -> (HappyAbsSyn )+happyIn311 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap311 x)+{-# INLINE happyIn311 #-}+happyOut311 :: (HappyAbsSyn ) -> HappyWrap311+happyOut311 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut311 #-}+newtype HappyWrap312 = HappyWrap312 (Located RdrName)+happyIn312 :: (Located RdrName) -> (HappyAbsSyn )+happyIn312 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap312 x)+{-# INLINE happyIn312 #-}+happyOut312 :: (HappyAbsSyn ) -> HappyWrap312+happyOut312 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut312 #-}+newtype HappyWrap313 = HappyWrap313 (Located RdrName)+happyIn313 :: (Located RdrName) -> (HappyAbsSyn )+happyIn313 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap313 x)+{-# INLINE happyIn313 #-}+happyOut313 :: (HappyAbsSyn ) -> HappyWrap313+happyOut313 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut313 #-}+newtype HappyWrap314 = HappyWrap314 (Located RdrName)+happyIn314 :: (Located RdrName) -> (HappyAbsSyn )+happyIn314 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap314 x)+{-# INLINE happyIn314 #-}+happyOut314 :: (HappyAbsSyn ) -> HappyWrap314+happyOut314 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut314 #-}+newtype HappyWrap315 = HappyWrap315 (Located RdrName)+happyIn315 :: (Located RdrName) -> (HappyAbsSyn )+happyIn315 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap315 x)+{-# INLINE happyIn315 #-}+happyOut315 :: (HappyAbsSyn ) -> HappyWrap315+happyOut315 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut315 #-}+newtype HappyWrap316 = HappyWrap316 (Located (HsLit GhcPs))+happyIn316 :: (Located (HsLit GhcPs)) -> (HappyAbsSyn )+happyIn316 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap316 x)+{-# INLINE happyIn316 #-}+happyOut316 :: (HappyAbsSyn ) -> HappyWrap316+happyOut316 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut316 #-}+newtype HappyWrap317 = HappyWrap317 (())+happyIn317 :: (()) -> (HappyAbsSyn )+happyIn317 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap317 x)+{-# INLINE happyIn317 #-}+happyOut317 :: (HappyAbsSyn ) -> HappyWrap317+happyOut317 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut317 #-}+newtype HappyWrap318 = HappyWrap318 (Located ModuleName)+happyIn318 :: (Located ModuleName) -> (HappyAbsSyn )+happyIn318 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap318 x)+{-# INLINE happyIn318 #-}+happyOut318 :: (HappyAbsSyn ) -> HappyWrap318+happyOut318 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut318 #-}+newtype HappyWrap319 = HappyWrap319 (([SrcSpan],Int))+happyIn319 :: (([SrcSpan],Int)) -> (HappyAbsSyn )+happyIn319 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap319 x)+{-# INLINE happyIn319 #-}+happyOut319 :: (HappyAbsSyn ) -> HappyWrap319+happyOut319 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut319 #-}+newtype HappyWrap320 = HappyWrap320 (([SrcSpan],Int))+happyIn320 :: (([SrcSpan],Int)) -> (HappyAbsSyn )+happyIn320 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap320 x)+{-# INLINE happyIn320 #-}+happyOut320 :: (HappyAbsSyn ) -> HappyWrap320+happyOut320 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut320 #-}+newtype HappyWrap321 = HappyWrap321 (([SrcSpan],Int))+happyIn321 :: (([SrcSpan],Int)) -> (HappyAbsSyn )+happyIn321 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap321 x)+{-# INLINE happyIn321 #-}+happyOut321 :: (HappyAbsSyn ) -> HappyWrap321+happyOut321 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut321 #-}+newtype HappyWrap322 = HappyWrap322 (LHsDocString)+happyIn322 :: (LHsDocString) -> (HappyAbsSyn )+happyIn322 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap322 x)+{-# INLINE happyIn322 #-}+happyOut322 :: (HappyAbsSyn ) -> HappyWrap322+happyOut322 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut322 #-}+newtype HappyWrap323 = HappyWrap323 (LHsDocString)+happyIn323 :: (LHsDocString) -> (HappyAbsSyn )+happyIn323 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap323 x)+{-# INLINE happyIn323 #-}+happyOut323 :: (HappyAbsSyn ) -> HappyWrap323+happyOut323 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut323 #-}+newtype HappyWrap324 = HappyWrap324 (Located (String, HsDocString))+happyIn324 :: (Located (String, HsDocString)) -> (HappyAbsSyn )+happyIn324 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap324 x)+{-# INLINE happyIn324 #-}+happyOut324 :: (HappyAbsSyn ) -> HappyWrap324+happyOut324 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut324 #-}+newtype HappyWrap325 = HappyWrap325 (Located (Int, HsDocString))+happyIn325 :: (Located (Int, HsDocString)) -> (HappyAbsSyn )+happyIn325 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap325 x)+{-# INLINE happyIn325 #-}+happyOut325 :: (HappyAbsSyn ) -> HappyWrap325+happyOut325 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut325 #-}+newtype HappyWrap326 = HappyWrap326 (Maybe LHsDocString)+happyIn326 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn326 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap326 x)+{-# INLINE happyIn326 #-}+happyOut326 :: (HappyAbsSyn ) -> HappyWrap326+happyOut326 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut326 #-}+newtype HappyWrap327 = HappyWrap327 (Maybe LHsDocString)+happyIn327 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn327 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap327 x)+{-# INLINE happyIn327 #-}+happyOut327 :: (HappyAbsSyn ) -> HappyWrap327+happyOut327 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut327 #-}+newtype HappyWrap328 = HappyWrap328 (Maybe LHsDocString)+happyIn328 :: (Maybe LHsDocString) -> (HappyAbsSyn )+happyIn328 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap328 x)+{-# INLINE happyIn328 #-}+happyOut328 :: (HappyAbsSyn ) -> HappyWrap328+happyOut328 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut328 #-}+newtype HappyWrap329 = HappyWrap329 (ECP)+happyIn329 :: (ECP) -> (HappyAbsSyn )+happyIn329 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap329 x)+{-# INLINE happyIn329 #-}+happyOut329 :: (HappyAbsSyn ) -> HappyWrap329+happyOut329 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut329 #-}+newtype HappyWrap330 = HappyWrap330 (ECP)+happyIn330 :: (ECP) -> (HappyAbsSyn )+happyIn330 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap330 x)+{-# INLINE happyIn330 #-}+happyOut330 :: (HappyAbsSyn ) -> HappyWrap330+happyOut330 x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOut330 #-}+happyInTok :: ((Located Token)) -> (HappyAbsSyn )+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyInTok #-}+happyOutTok :: (HappyAbsSyn ) -> ((Located Token))+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x+{-# INLINE happyOutTok #-}+++happyExpList :: HappyAddr+happyExpList = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xe0\xd0\x40\x44\xff\x7f\xe1\x07\x00\x00\x10\x30\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\x43\x03\x11\xfd\xff\x85\x1f\x00\x00\x40\xc0\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 * 479+        bit_end = (st + 1) * 479+        read_bit = readArrayBit happyExpList+        bits = map read_bit [bit_start..bit_end - 1]+        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# "\x4b\x00\xe1\xff\x97\x00\xc6\x25\x36\x1a\xaa\x28\xaa\x28\x0a\x24\xc6\x25\x51\x54\x4d\x39\x8a\x00\x44\x00\x3d\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\x21\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\x9a\x40\x9a\x40\x00\x00\x00\x00\x9a\x40\x34\x00\x5c\x34\x60\x32\xdf\x32\xd9\x56\xb5\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\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\x42\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\x56\x31\x4d\x05\x56\x31\xe4\x02\xaf\x01\xe7\x02\x06\x2f\x9a\x2f\x56\x31\x56\x31\x92\x20\x1a\x1d\xae\x1d\x56\x31\xb1\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\x4d\x39\x58\x05\xaa\x28\xdb\x31\x77\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\x3d\x57\xf9\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\x21\x40\x3b\x04\x05\x04\x1f\x04\x7b\x05\x00\x00\xd5\x34\x61\x00\x26\x58\x13\x04\x53\x58\x53\x58\xcc\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\x56\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x31\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\x34\x59\xd7\x04\x23\x01\x26\x02\x00\x00\x23\x06\x23\x06\x9e\x00\xdf\x04\xe3\x04\xaf\x00\x41\x3c\x21\x40\x02\x03\x4d\x39\xf3\x04\x0f\x05\x12\x05\x1d\x05\x00\x00\x34\x05\x00\x00\x00\x00\x00\x00\x21\x40\x4d\x39\x21\x40\x1a\x05\x3d\x05\x00\x00\xe1\x01\x00\x00\xaa\x28\x00\x00\x00\x00\x54\x35\x16\x55\x21\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\x16\x55\x83\x05\x86\x05\xc6\x05\x00\x00\xab\x05\x00\x00\xad\x05\x00\x00\x6a\x57\x28\x00\x3d\x57\x00\x00\x64\x01\x3d\x57\x4d\x39\x3d\x57\x00\x00\x1b\x06\xd6\x1e\xd6\x1e\x8a\x59\xd3\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\x56\x31\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\x56\x31\xd2\x29\x06\x57\x00\x00\x9a\x40\x00\x00\x4d\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\x4d\x39\x5e\x33\xa4\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\x8a\x59\x00\x00\x15\x56\x00\x00\x00\x00\x00\x00\x00\x00\x23\x02\x5a\x0d\x00\x00\x5f\x5a\x21\x40\x00\x00\x4d\x39\x4d\x39\x4d\x39\x39\x02\x00\x00\x76\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\x4d\x39\x00\x00\x00\x00\x2e\x01\x00\x00\xaf\x02\x93\x06\x00\x00\x00\x00\x4d\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x39\x00\x00\x00\x00\x00\x00\x4d\x39\x4d\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\x56\x31\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\xc2\x30\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\xda\x58\x00\x00\x00\x00\xda\x06\x00\x00\x3c\x02\xe4\x06\x21\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\x80\x58\x80\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\xc0\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\x21\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\xd3\x35\xd3\x35\x02\x03\xbb\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x41\x08\x32\x08\x07\xd3\x35\x00\x00\x08\x32\x8a\x59\xfa\x2a\xfa\x2a\x5d\x07\x00\x00\x0d\x02\x00\x00\xfd\x06\x00\x00\x02\x07\x00\x00\x00\x00\xad\x58\xad\x58\x00\x00\x00\x00\xad\x58\x56\x31\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\xb7\x59\x71\x07\x00\x00\x29\x07\x25\x07\x00\x00\x00\x00\x1d\x07\x00\x00\x49\x41\x00\x00\x43\x07\x44\x07\x46\x07\x47\x07\xe4\x59\x00\x00\x00\x00\x00\x00\x49\x07\x00\x00\x3b\x07\x4d\x39\x4b\x07\x4d\x39\x5a\x0d\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x05\x4d\x39\x00\x00\x00\x00\x4d\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\x21\x40\x4c\x07\x52\x36\x52\x36\x88\x07\x9f\x07\x58\x07\x4d\x39\x7f\x01\x52\x07\x00\x00\x3e\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\x4d\x39\x00\x00\x4e\x07\x4d\x39\x00\x00\x00\x00\x00\x00\x36\x07\x00\x00\xd6\x1e\xfa\x2a\x00\x00\x00\x00\xd1\x36\xe4\x59\x52\x03\x5e\x07\x21\x40\xd1\x36\xd1\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\x06\x57\x00\x00\x00\x00\x00\x00\x4d\x39\x00\x00\x00\x00\x66\x07\x00\x00\x59\x07\x61\x07\x3e\x07\x4d\x39\x00\x00\x4d\x39\x07\x59\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\xd1\x36\xd1\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\x21\x40\xce\x07\xea\x07\x00\x00\x70\x07\x00\x00\xeb\x07\x00\x00\x50\x03\xeb\x07\x15\x06\xd1\x36\x86\x02\x50\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\x5f\x5a\x00\x00\x21\x40\x4d\x39\xab\x07\xcf\x37\x00\x00\x00\x00\xe4\x59\x00\x00\x00\x00\x41\x06\x9b\x07\x11\x5a\x00\x00\x08\x32\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\xcf\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\x5f\x5a\x00\x00\x00\x00\x90\x01\x00\x00\xf0\x07\xde\x2d\x4f\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\xdd\x33\x00\x00\x1c\x00\x00\x00\xfd\x07\x00\x00\x0f\x08\x00\x00\x21\x40\x00\x00\x00\x00\x4d\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\x97\x41\xd5\x03\x51\x06\xb5\x07\x00\x00\x43\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\xc4\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\x39\x3d\x3e\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\xb8\x3d\x21\x40\x73\x0c\x21\x40\x00\x00\x00\x00\x00\x00\x86\x1c\xb8\x3d\x00\x00\x00\x00\x01\x08\x00\x00\xcc\x39\x4b\x3a\x5f\x5a\xca\x3a\x00\x00\x24\x02\x02\x04\x11\x5a\xca\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\x5f\x5a\x00\x00\x28\x02\x00\x00\x58\x00\x18\x04\xf3\x07\x37\x3e\x00\x00\x00\x00\x0a\x08\xce\x38\x31\x05\x00\x00\x00\x00\xca\x3a\x49\x3b\x00\x00\x00\x00\xd1\x03\xce\x38\x87\x03\x00\x00\x00\x00\xce\x38\xd5\x07\xfe\x07\x03\x08\x00\x00\xc2\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x21\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\xde\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\xb0\x3e\x00\x00\xf2\x07\x00\x00\x00\x00\x00\x00\x00\x00\x17\x08\x1c\x08\x60\x32\x00\x00\x00\x00\x3e\x5a\x00\x00\x00\x00\x7f\x01\x00\x00\x00\x00\x2f\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\x5f\x5a\x00\x00\xa8\x3f\x00\x00\x00\x00\x63\x08\x16\x08\x06\x10\x7d\x04\x00\x00\x7d\x04\x7d\x04\x00\x00\x7d\x04\xde\x55\x00\x00\x00\x00\x7a\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\x5a\x08\x66\x47\x49\x01\xd8\x4b\x06\x4b\xd0\xff\xac\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\xfc\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1e\x4c\xbe\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\x64\x4c\xa0\x07\xa6\x49\x71\x05\xa1\x07\xfc\x5b\xa2\x07\x3a\x5c\x00\x00\x00\x00\x00\x00\x3a\x5b\x4a\x5b\x4a\x5c\x88\x5c\x24\x43\xcb\x41\xb1\x42\xc6\x5c\x2e\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x4c\xd5\x59\x24\x13\xbf\x07\xf0\x4c\xdc\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\x3e\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\xd6\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x5d\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\x4d\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\xe8\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x43\x6b\x44\x00\x00\x4a\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\x91\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x5d\x00\x00\xc6\x5a\xd6\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x47\x38\x48\x00\x00\x00\x00\x00\x00\x04\x08\xb8\xff\x00\x00\x00\x00\x7e\x48\xe4\x05\x00\x00\x00\x00\x62\x5d\x36\x4d\x9b\x02\x00\x00\xb4\x05\x00\x00\xf9\x10\x7c\x4d\xc2\x4d\x08\x4e\x4e\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\x94\x4e\xda\x4e\x97\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x48\xd9\x46\xd6\x5a\x00\x00\xd8\x44\x00\x00\x20\x4f\x8c\x46\x45\x45\x00\x00\x92\xff\x00\x00\x00\x00\x00\x00\xfe\x43\x00\x00\x00\x00\xae\x5b\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\x4d\x41\xb2\x45\x00\x00\xcc\x04\xb0\xff\x00\x00\x00\x00\x96\x07\x00\x00\x65\x01\x00\x00\x00\x00\x5d\x41\x00\x00\x00\x00\xf8\xff\x00\x00\x66\x4f\x11\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\x4c\x4b\x92\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\xa0\x5d\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\x52\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\xac\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\xf2\x4f\x00\x00\x00\x00\x38\x50\x00\x00\xde\x07\x00\x00\x00\x00\x10\x05\x00\x00\x5e\x49\x00\x00\x00\x00\x00\x00\x00\x00\xec\x49\x00\x00\x00\x00\x00\x00\x7e\x50\x78\x4a\xc4\x50\x00\x00\x00\x00\x1f\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\x0a\x51\xc0\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x20\x47\x32\x4a\x50\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\x96\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\xdc\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\x62\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\x22\x52\x68\x52\xae\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\xf4\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\x3a\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++happyDefActions :: HappyAddr+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\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\xff\xff\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\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\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\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\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\x1f\x00\x20\x00\x21\x00\xff\xff\x71\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\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\x67\x00\xff\xff\xff\xff\xff\xff\xc1\x00\xff\xff\xc3\x00\xff\xff\xc5\x00\xff\xff\x71\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\xff\xff\xff\xff\xf7\x00\xf8\x00\xff\xff\xff\xff\x71\x00\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\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\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\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\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\xd0\x00\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\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\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\xc5\x01\x00\x00\x96\x00\x97\x00\x48\x05\x00\x00\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\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\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\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\x2c\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\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\x23\x04\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x51\x00\x52\x00\x53\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\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x8d\x00\x00\x00\x89\x01\x00\x00\x90\x00\x00\x00\x00\x00\x92\x00\x93\x00\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\xed\x01\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\xb4\x02\x00\x00\x90\x00\x00\x00\x63\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\x9c\x00\x9d\x00\x00\x00\x00\x00\x63\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\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\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\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\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\x83\x03\x94\x00\x95\x00\x00\x00\x96\x00\x97\x00\x00\x00\x84\x03\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x8e\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\x82\x01\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\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"#++happyReduceArr = Happy_Data_Array.array (13, 826) [+	(13 , happyReduce_13),+	(14 , happyReduce_14),+	(15 , happyReduce_15),+	(16 , happyReduce_16),+	(17 , happyReduce_17),+	(18 , happyReduce_18),+	(19 , happyReduce_19),+	(20 , happyReduce_20),+	(21 , happyReduce_21),+	(22 , happyReduce_22),+	(23 , happyReduce_23),+	(24 , happyReduce_24),+	(25 , happyReduce_25),+	(26 , happyReduce_26),+	(27 , happyReduce_27),+	(28 , happyReduce_28),+	(29 , happyReduce_29),+	(30 , happyReduce_30),+	(31 , happyReduce_31),+	(32 , happyReduce_32),+	(33 , happyReduce_33),+	(34 , happyReduce_34),+	(35 , happyReduce_35),+	(36 , happyReduce_36),+	(37 , happyReduce_37),+	(38 , happyReduce_38),+	(39 , happyReduce_39),+	(40 , happyReduce_40),+	(41 , happyReduce_41),+	(42 , happyReduce_42),+	(43 , happyReduce_43),+	(44 , happyReduce_44),+	(45 , happyReduce_45),+	(46 , happyReduce_46),+	(47 , happyReduce_47),+	(48 , happyReduce_48),+	(49 , happyReduce_49),+	(50 , happyReduce_50),+	(51 , happyReduce_51),+	(52 , happyReduce_52),+	(53 , happyReduce_53),+	(54 , happyReduce_54),+	(55 , happyReduce_55),+	(56 , happyReduce_56),+	(57 , happyReduce_57),+	(58 , happyReduce_58),+	(59 , happyReduce_59),+	(60 , happyReduce_60),+	(61 , happyReduce_61),+	(62 , happyReduce_62),+	(63 , happyReduce_63),+	(64 , happyReduce_64),+	(65 , happyReduce_65),+	(66 , happyReduce_66),+	(67 , happyReduce_67),+	(68 , happyReduce_68),+	(69 , happyReduce_69),+	(70 , happyReduce_70),+	(71 , happyReduce_71),+	(72 , happyReduce_72),+	(73 , happyReduce_73),+	(74 , happyReduce_74),+	(75 , happyReduce_75),+	(76 , happyReduce_76),+	(77 , happyReduce_77),+	(78 , happyReduce_78),+	(79 , happyReduce_79),+	(80 , happyReduce_80),+	(81 , happyReduce_81),+	(82 , happyReduce_82),+	(83 , happyReduce_83),+	(84 , happyReduce_84),+	(85 , happyReduce_85),+	(86 , happyReduce_86),+	(87 , happyReduce_87),+	(88 , happyReduce_88),+	(89 , happyReduce_89),+	(90 , happyReduce_90),+	(91 , happyReduce_91),+	(92 , happyReduce_92),+	(93 , happyReduce_93),+	(94 , happyReduce_94),+	(95 , happyReduce_95),+	(96 , happyReduce_96),+	(97 , happyReduce_97),+	(98 , happyReduce_98),+	(99 , happyReduce_99),+	(100 , happyReduce_100),+	(101 , happyReduce_101),+	(102 , happyReduce_102),+	(103 , happyReduce_103),+	(104 , happyReduce_104),+	(105 , happyReduce_105),+	(106 , happyReduce_106),+	(107 , happyReduce_107),+	(108 , happyReduce_108),+	(109 , happyReduce_109),+	(110 , happyReduce_110),+	(111 , happyReduce_111),+	(112 , happyReduce_112),+	(113 , happyReduce_113),+	(114 , happyReduce_114),+	(115 , happyReduce_115),+	(116 , happyReduce_116),+	(117 , happyReduce_117),+	(118 , happyReduce_118),+	(119 , happyReduce_119),+	(120 , happyReduce_120),+	(121 , happyReduce_121),+	(122 , happyReduce_122),+	(123 , happyReduce_123),+	(124 , happyReduce_124),+	(125 , happyReduce_125),+	(126 , happyReduce_126),+	(127 , happyReduce_127),+	(128 , happyReduce_128),+	(129 , happyReduce_129),+	(130 , happyReduce_130),+	(131 , happyReduce_131),+	(132 , happyReduce_132),+	(133 , happyReduce_133),+	(134 , happyReduce_134),+	(135 , happyReduce_135),+	(136 , happyReduce_136),+	(137 , happyReduce_137),+	(138 , happyReduce_138),+	(139 , happyReduce_139),+	(140 , happyReduce_140),+	(141 , happyReduce_141),+	(142 , happyReduce_142),+	(143 , happyReduce_143),+	(144 , happyReduce_144),+	(145 , happyReduce_145),+	(146 , happyReduce_146),+	(147 , happyReduce_147),+	(148 , happyReduce_148),+	(149 , happyReduce_149),+	(150 , happyReduce_150),+	(151 , happyReduce_151),+	(152 , happyReduce_152),+	(153 , happyReduce_153),+	(154 , happyReduce_154),+	(155 , happyReduce_155),+	(156 , happyReduce_156),+	(157 , happyReduce_157),+	(158 , happyReduce_158),+	(159 , happyReduce_159),+	(160 , happyReduce_160),+	(161 , happyReduce_161),+	(162 , happyReduce_162),+	(163 , happyReduce_163),+	(164 , happyReduce_164),+	(165 , happyReduce_165),+	(166 , happyReduce_166),+	(167 , happyReduce_167),+	(168 , happyReduce_168),+	(169 , happyReduce_169),+	(170 , happyReduce_170),+	(171 , happyReduce_171),+	(172 , happyReduce_172),+	(173 , happyReduce_173),+	(174 , happyReduce_174),+	(175 , happyReduce_175),+	(176 , happyReduce_176),+	(177 , happyReduce_177),+	(178 , happyReduce_178),+	(179 , happyReduce_179),+	(180 , happyReduce_180),+	(181 , happyReduce_181),+	(182 , happyReduce_182),+	(183 , happyReduce_183),+	(184 , happyReduce_184),+	(185 , happyReduce_185),+	(186 , happyReduce_186),+	(187 , happyReduce_187),+	(188 , happyReduce_188),+	(189 , happyReduce_189),+	(190 , happyReduce_190),+	(191 , happyReduce_191),+	(192 , happyReduce_192),+	(193 , happyReduce_193),+	(194 , happyReduce_194),+	(195 , happyReduce_195),+	(196 , happyReduce_196),+	(197 , happyReduce_197),+	(198 , happyReduce_198),+	(199 , happyReduce_199),+	(200 , happyReduce_200),+	(201 , happyReduce_201),+	(202 , happyReduce_202),+	(203 , happyReduce_203),+	(204 , happyReduce_204),+	(205 , happyReduce_205),+	(206 , happyReduce_206),+	(207 , happyReduce_207),+	(208 , happyReduce_208),+	(209 , happyReduce_209),+	(210 , happyReduce_210),+	(211 , happyReduce_211),+	(212 , happyReduce_212),+	(213 , happyReduce_213),+	(214 , happyReduce_214),+	(215 , happyReduce_215),+	(216 , happyReduce_216),+	(217 , happyReduce_217),+	(218 , happyReduce_218),+	(219 , happyReduce_219),+	(220 , happyReduce_220),+	(221 , happyReduce_221),+	(222 , happyReduce_222),+	(223 , happyReduce_223),+	(224 , happyReduce_224),+	(225 , happyReduce_225),+	(226 , happyReduce_226),+	(227 , happyReduce_227),+	(228 , happyReduce_228),+	(229 , happyReduce_229),+	(230 , happyReduce_230),+	(231 , happyReduce_231),+	(232 , happyReduce_232),+	(233 , happyReduce_233),+	(234 , happyReduce_234),+	(235 , happyReduce_235),+	(236 , happyReduce_236),+	(237 , happyReduce_237),+	(238 , happyReduce_238),+	(239 , happyReduce_239),+	(240 , happyReduce_240),+	(241 , happyReduce_241),+	(242 , happyReduce_242),+	(243 , happyReduce_243),+	(244 , happyReduce_244),+	(245 , happyReduce_245),+	(246 , happyReduce_246),+	(247 , happyReduce_247),+	(248 , happyReduce_248),+	(249 , happyReduce_249),+	(250 , happyReduce_250),+	(251 , happyReduce_251),+	(252 , happyReduce_252),+	(253 , happyReduce_253),+	(254 , happyReduce_254),+	(255 , happyReduce_255),+	(256 , happyReduce_256),+	(257 , happyReduce_257),+	(258 , happyReduce_258),+	(259 , happyReduce_259),+	(260 , happyReduce_260),+	(261 , happyReduce_261),+	(262 , happyReduce_262),+	(263 , happyReduce_263),+	(264 , happyReduce_264),+	(265 , happyReduce_265),+	(266 , happyReduce_266),+	(267 , happyReduce_267),+	(268 , happyReduce_268),+	(269 , happyReduce_269),+	(270 , happyReduce_270),+	(271 , happyReduce_271),+	(272 , happyReduce_272),+	(273 , happyReduce_273),+	(274 , happyReduce_274),+	(275 , happyReduce_275),+	(276 , happyReduce_276),+	(277 , happyReduce_277),+	(278 , happyReduce_278),+	(279 , happyReduce_279),+	(280 , happyReduce_280),+	(281 , happyReduce_281),+	(282 , happyReduce_282),+	(283 , happyReduce_283),+	(284 , happyReduce_284),+	(285 , happyReduce_285),+	(286 , happyReduce_286),+	(287 , happyReduce_287),+	(288 , happyReduce_288),+	(289 , happyReduce_289),+	(290 , happyReduce_290),+	(291 , happyReduce_291),+	(292 , happyReduce_292),+	(293 , happyReduce_293),+	(294 , happyReduce_294),+	(295 , happyReduce_295),+	(296 , happyReduce_296),+	(297 , happyReduce_297),+	(298 , happyReduce_298),+	(299 , happyReduce_299),+	(300 , happyReduce_300),+	(301 , happyReduce_301),+	(302 , happyReduce_302),+	(303 , happyReduce_303),+	(304 , happyReduce_304),+	(305 , happyReduce_305),+	(306 , happyReduce_306),+	(307 , happyReduce_307),+	(308 , happyReduce_308),+	(309 , happyReduce_309),+	(310 , happyReduce_310),+	(311 , happyReduce_311),+	(312 , happyReduce_312),+	(313 , happyReduce_313),+	(314 , happyReduce_314),+	(315 , happyReduce_315),+	(316 , happyReduce_316),+	(317 , happyReduce_317),+	(318 , happyReduce_318),+	(319 , happyReduce_319),+	(320 , happyReduce_320),+	(321 , happyReduce_321),+	(322 , happyReduce_322),+	(323 , happyReduce_323),+	(324 , happyReduce_324),+	(325 , happyReduce_325),+	(326 , happyReduce_326),+	(327 , happyReduce_327),+	(328 , happyReduce_328),+	(329 , happyReduce_329),+	(330 , happyReduce_330),+	(331 , happyReduce_331),+	(332 , happyReduce_332),+	(333 , happyReduce_333),+	(334 , happyReduce_334),+	(335 , happyReduce_335),+	(336 , happyReduce_336),+	(337 , happyReduce_337),+	(338 , happyReduce_338),+	(339 , happyReduce_339),+	(340 , happyReduce_340),+	(341 , happyReduce_341),+	(342 , happyReduce_342),+	(343 , happyReduce_343),+	(344 , happyReduce_344),+	(345 , happyReduce_345),+	(346 , happyReduce_346),+	(347 , happyReduce_347),+	(348 , happyReduce_348),+	(349 , happyReduce_349),+	(350 , happyReduce_350),+	(351 , happyReduce_351),+	(352 , happyReduce_352),+	(353 , happyReduce_353),+	(354 , happyReduce_354),+	(355 , happyReduce_355),+	(356 , happyReduce_356),+	(357 , happyReduce_357),+	(358 , happyReduce_358),+	(359 , happyReduce_359),+	(360 , happyReduce_360),+	(361 , happyReduce_361),+	(362 , happyReduce_362),+	(363 , happyReduce_363),+	(364 , happyReduce_364),+	(365 , happyReduce_365),+	(366 , happyReduce_366),+	(367 , happyReduce_367),+	(368 , happyReduce_368),+	(369 , happyReduce_369),+	(370 , happyReduce_370),+	(371 , happyReduce_371),+	(372 , happyReduce_372),+	(373 , happyReduce_373),+	(374 , happyReduce_374),+	(375 , happyReduce_375),+	(376 , happyReduce_376),+	(377 , happyReduce_377),+	(378 , happyReduce_378),+	(379 , happyReduce_379),+	(380 , happyReduce_380),+	(381 , happyReduce_381),+	(382 , happyReduce_382),+	(383 , happyReduce_383),+	(384 , happyReduce_384),+	(385 , happyReduce_385),+	(386 , happyReduce_386),+	(387 , happyReduce_387),+	(388 , happyReduce_388),+	(389 , happyReduce_389),+	(390 , happyReduce_390),+	(391 , happyReduce_391),+	(392 , happyReduce_392),+	(393 , happyReduce_393),+	(394 , happyReduce_394),+	(395 , happyReduce_395),+	(396 , happyReduce_396),+	(397 , happyReduce_397),+	(398 , happyReduce_398),+	(399 , happyReduce_399),+	(400 , happyReduce_400),+	(401 , happyReduce_401),+	(402 , happyReduce_402),+	(403 , happyReduce_403),+	(404 , happyReduce_404),+	(405 , happyReduce_405),+	(406 , happyReduce_406),+	(407 , happyReduce_407),+	(408 , happyReduce_408),+	(409 , happyReduce_409),+	(410 , happyReduce_410),+	(411 , happyReduce_411),+	(412 , happyReduce_412),+	(413 , happyReduce_413),+	(414 , happyReduce_414),+	(415 , happyReduce_415),+	(416 , happyReduce_416),+	(417 , happyReduce_417),+	(418 , happyReduce_418),+	(419 , happyReduce_419),+	(420 , happyReduce_420),+	(421 , happyReduce_421),+	(422 , happyReduce_422),+	(423 , happyReduce_423),+	(424 , happyReduce_424),+	(425 , happyReduce_425),+	(426 , happyReduce_426),+	(427 , happyReduce_427),+	(428 , happyReduce_428),+	(429 , happyReduce_429),+	(430 , happyReduce_430),+	(431 , happyReduce_431),+	(432 , happyReduce_432),+	(433 , happyReduce_433),+	(434 , happyReduce_434),+	(435 , happyReduce_435),+	(436 , happyReduce_436),+	(437 , happyReduce_437),+	(438 , happyReduce_438),+	(439 , happyReduce_439),+	(440 , happyReduce_440),+	(441 , happyReduce_441),+	(442 , happyReduce_442),+	(443 , happyReduce_443),+	(444 , happyReduce_444),+	(445 , happyReduce_445),+	(446 , happyReduce_446),+	(447 , happyReduce_447),+	(448 , happyReduce_448),+	(449 , happyReduce_449),+	(450 , happyReduce_450),+	(451 , happyReduce_451),+	(452 , happyReduce_452),+	(453 , happyReduce_453),+	(454 , happyReduce_454),+	(455 , happyReduce_455),+	(456 , happyReduce_456),+	(457 , happyReduce_457),+	(458 , happyReduce_458),+	(459 , happyReduce_459),+	(460 , happyReduce_460),+	(461 , happyReduce_461),+	(462 , happyReduce_462),+	(463 , happyReduce_463),+	(464 , happyReduce_464),+	(465 , happyReduce_465),+	(466 , happyReduce_466),+	(467 , happyReduce_467),+	(468 , happyReduce_468),+	(469 , happyReduce_469),+	(470 , happyReduce_470),+	(471 , happyReduce_471),+	(472 , happyReduce_472),+	(473 , happyReduce_473),+	(474 , happyReduce_474),+	(475 , happyReduce_475),+	(476 , happyReduce_476),+	(477 , happyReduce_477),+	(478 , happyReduce_478),+	(479 , happyReduce_479),+	(480 , happyReduce_480),+	(481 , happyReduce_481),+	(482 , happyReduce_482),+	(483 , happyReduce_483),+	(484 , happyReduce_484),+	(485 , happyReduce_485),+	(486 , happyReduce_486),+	(487 , happyReduce_487),+	(488 , happyReduce_488),+	(489 , happyReduce_489),+	(490 , happyReduce_490),+	(491 , happyReduce_491),+	(492 , happyReduce_492),+	(493 , happyReduce_493),+	(494 , happyReduce_494),+	(495 , happyReduce_495),+	(496 , happyReduce_496),+	(497 , happyReduce_497),+	(498 , happyReduce_498),+	(499 , happyReduce_499),+	(500 , happyReduce_500),+	(501 , happyReduce_501),+	(502 , happyReduce_502),+	(503 , happyReduce_503),+	(504 , happyReduce_504),+	(505 , happyReduce_505),+	(506 , happyReduce_506),+	(507 , happyReduce_507),+	(508 , happyReduce_508),+	(509 , happyReduce_509),+	(510 , happyReduce_510),+	(511 , happyReduce_511),+	(512 , happyReduce_512),+	(513 , happyReduce_513),+	(514 , happyReduce_514),+	(515 , happyReduce_515),+	(516 , happyReduce_516),+	(517 , happyReduce_517),+	(518 , happyReduce_518),+	(519 , happyReduce_519),+	(520 , happyReduce_520),+	(521 , happyReduce_521),+	(522 , happyReduce_522),+	(523 , happyReduce_523),+	(524 , happyReduce_524),+	(525 , happyReduce_525),+	(526 , happyReduce_526),+	(527 , happyReduce_527),+	(528 , happyReduce_528),+	(529 , happyReduce_529),+	(530 , happyReduce_530),+	(531 , happyReduce_531),+	(532 , happyReduce_532),+	(533 , happyReduce_533),+	(534 , happyReduce_534),+	(535 , happyReduce_535),+	(536 , happyReduce_536),+	(537 , happyReduce_537),+	(538 , happyReduce_538),+	(539 , happyReduce_539),+	(540 , happyReduce_540),+	(541 , happyReduce_541),+	(542 , happyReduce_542),+	(543 , happyReduce_543),+	(544 , happyReduce_544),+	(545 , happyReduce_545),+	(546 , happyReduce_546),+	(547 , happyReduce_547),+	(548 , happyReduce_548),+	(549 , happyReduce_549),+	(550 , happyReduce_550),+	(551 , happyReduce_551),+	(552 , happyReduce_552),+	(553 , happyReduce_553),+	(554 , happyReduce_554),+	(555 , happyReduce_555),+	(556 , happyReduce_556),+	(557 , happyReduce_557),+	(558 , happyReduce_558),+	(559 , happyReduce_559),+	(560 , happyReduce_560),+	(561 , happyReduce_561),+	(562 , happyReduce_562),+	(563 , happyReduce_563),+	(564 , happyReduce_564),+	(565 , happyReduce_565),+	(566 , happyReduce_566),+	(567 , happyReduce_567),+	(568 , happyReduce_568),+	(569 , happyReduce_569),+	(570 , happyReduce_570),+	(571 , happyReduce_571),+	(572 , happyReduce_572),+	(573 , happyReduce_573),+	(574 , happyReduce_574),+	(575 , happyReduce_575),+	(576 , happyReduce_576),+	(577 , happyReduce_577),+	(578 , happyReduce_578),+	(579 , happyReduce_579),+	(580 , happyReduce_580),+	(581 , happyReduce_581),+	(582 , happyReduce_582),+	(583 , happyReduce_583),+	(584 , happyReduce_584),+	(585 , happyReduce_585),+	(586 , happyReduce_586),+	(587 , happyReduce_587),+	(588 , happyReduce_588),+	(589 , happyReduce_589),+	(590 , happyReduce_590),+	(591 , happyReduce_591),+	(592 , happyReduce_592),+	(593 , happyReduce_593),+	(594 , happyReduce_594),+	(595 , happyReduce_595),+	(596 , happyReduce_596),+	(597 , happyReduce_597),+	(598 , happyReduce_598),+	(599 , happyReduce_599),+	(600 , happyReduce_600),+	(601 , happyReduce_601),+	(602 , happyReduce_602),+	(603 , happyReduce_603),+	(604 , happyReduce_604),+	(605 , happyReduce_605),+	(606 , happyReduce_606),+	(607 , happyReduce_607),+	(608 , happyReduce_608),+	(609 , happyReduce_609),+	(610 , happyReduce_610),+	(611 , happyReduce_611),+	(612 , happyReduce_612),+	(613 , happyReduce_613),+	(614 , happyReduce_614),+	(615 , happyReduce_615),+	(616 , happyReduce_616),+	(617 , happyReduce_617),+	(618 , happyReduce_618),+	(619 , happyReduce_619),+	(620 , happyReduce_620),+	(621 , happyReduce_621),+	(622 , happyReduce_622),+	(623 , happyReduce_623),+	(624 , happyReduce_624),+	(625 , happyReduce_625),+	(626 , happyReduce_626),+	(627 , happyReduce_627),+	(628 , happyReduce_628),+	(629 , happyReduce_629),+	(630 , happyReduce_630),+	(631 , happyReduce_631),+	(632 , happyReduce_632),+	(633 , happyReduce_633),+	(634 , happyReduce_634),+	(635 , happyReduce_635),+	(636 , happyReduce_636),+	(637 , happyReduce_637),+	(638 , happyReduce_638),+	(639 , happyReduce_639),+	(640 , happyReduce_640),+	(641 , happyReduce_641),+	(642 , happyReduce_642),+	(643 , happyReduce_643),+	(644 , happyReduce_644),+	(645 , happyReduce_645),+	(646 , happyReduce_646),+	(647 , happyReduce_647),+	(648 , happyReduce_648),+	(649 , happyReduce_649),+	(650 , happyReduce_650),+	(651 , happyReduce_651),+	(652 , happyReduce_652),+	(653 , happyReduce_653),+	(654 , happyReduce_654),+	(655 , happyReduce_655),+	(656 , happyReduce_656),+	(657 , happyReduce_657),+	(658 , happyReduce_658),+	(659 , happyReduce_659),+	(660 , happyReduce_660),+	(661 , happyReduce_661),+	(662 , happyReduce_662),+	(663 , happyReduce_663),+	(664 , happyReduce_664),+	(665 , happyReduce_665),+	(666 , happyReduce_666),+	(667 , happyReduce_667),+	(668 , happyReduce_668),+	(669 , happyReduce_669),+	(670 , happyReduce_670),+	(671 , happyReduce_671),+	(672 , happyReduce_672),+	(673 , happyReduce_673),+	(674 , happyReduce_674),+	(675 , happyReduce_675),+	(676 , happyReduce_676),+	(677 , happyReduce_677),+	(678 , happyReduce_678),+	(679 , happyReduce_679),+	(680 , happyReduce_680),+	(681 , happyReduce_681),+	(682 , happyReduce_682),+	(683 , happyReduce_683),+	(684 , happyReduce_684),+	(685 , happyReduce_685),+	(686 , happyReduce_686),+	(687 , happyReduce_687),+	(688 , happyReduce_688),+	(689 , happyReduce_689),+	(690 , happyReduce_690),+	(691 , happyReduce_691),+	(692 , happyReduce_692),+	(693 , happyReduce_693),+	(694 , happyReduce_694),+	(695 , happyReduce_695),+	(696 , happyReduce_696),+	(697 , happyReduce_697),+	(698 , happyReduce_698),+	(699 , happyReduce_699),+	(700 , happyReduce_700),+	(701 , happyReduce_701),+	(702 , happyReduce_702),+	(703 , happyReduce_703),+	(704 , happyReduce_704),+	(705 , happyReduce_705),+	(706 , happyReduce_706),+	(707 , happyReduce_707),+	(708 , happyReduce_708),+	(709 , happyReduce_709),+	(710 , happyReduce_710),+	(711 , happyReduce_711),+	(712 , happyReduce_712),+	(713 , happyReduce_713),+	(714 , happyReduce_714),+	(715 , happyReduce_715),+	(716 , happyReduce_716),+	(717 , happyReduce_717),+	(718 , happyReduce_718),+	(719 , happyReduce_719),+	(720 , happyReduce_720),+	(721 , happyReduce_721),+	(722 , happyReduce_722),+	(723 , happyReduce_723),+	(724 , happyReduce_724),+	(725 , happyReduce_725),+	(726 , happyReduce_726),+	(727 , happyReduce_727),+	(728 , happyReduce_728),+	(729 , happyReduce_729),+	(730 , happyReduce_730),+	(731 , happyReduce_731),+	(732 , happyReduce_732),+	(733 , happyReduce_733),+	(734 , happyReduce_734),+	(735 , happyReduce_735),+	(736 , happyReduce_736),+	(737 , happyReduce_737),+	(738 , happyReduce_738),+	(739 , happyReduce_739),+	(740 , happyReduce_740),+	(741 , happyReduce_741),+	(742 , happyReduce_742),+	(743 , happyReduce_743),+	(744 , happyReduce_744),+	(745 , happyReduce_745),+	(746 , happyReduce_746),+	(747 , happyReduce_747),+	(748 , happyReduce_748),+	(749 , happyReduce_749),+	(750 , happyReduce_750),+	(751 , happyReduce_751),+	(752 , happyReduce_752),+	(753 , happyReduce_753),+	(754 , happyReduce_754),+	(755 , happyReduce_755),+	(756 , happyReduce_756),+	(757 , happyReduce_757),+	(758 , happyReduce_758),+	(759 , happyReduce_759),+	(760 , happyReduce_760),+	(761 , happyReduce_761),+	(762 , happyReduce_762),+	(763 , happyReduce_763),+	(764 , happyReduce_764),+	(765 , happyReduce_765),+	(766 , happyReduce_766),+	(767 , happyReduce_767),+	(768 , happyReduce_768),+	(769 , happyReduce_769),+	(770 , happyReduce_770),+	(771 , happyReduce_771),+	(772 , happyReduce_772),+	(773 , happyReduce_773),+	(774 , happyReduce_774),+	(775 , happyReduce_775),+	(776 , happyReduce_776),+	(777 , happyReduce_777),+	(778 , happyReduce_778),+	(779 , happyReduce_779),+	(780 , happyReduce_780),+	(781 , happyReduce_781),+	(782 , happyReduce_782),+	(783 , happyReduce_783),+	(784 , happyReduce_784),+	(785 , happyReduce_785),+	(786 , happyReduce_786),+	(787 , happyReduce_787),+	(788 , happyReduce_788),+	(789 , happyReduce_789),+	(790 , happyReduce_790),+	(791 , happyReduce_791),+	(792 , happyReduce_792),+	(793 , happyReduce_793),+	(794 , happyReduce_794),+	(795 , happyReduce_795),+	(796 , happyReduce_796),+	(797 , happyReduce_797),+	(798 , happyReduce_798),+	(799 , happyReduce_799),+	(800 , happyReduce_800),+	(801 , happyReduce_801),+	(802 , happyReduce_802),+	(803 , happyReduce_803),+	(804 , happyReduce_804),+	(805 , happyReduce_805),+	(806 , happyReduce_806),+	(807 , happyReduce_807),+	(808 , happyReduce_808),+	(809 , happyReduce_809),+	(810 , happyReduce_810),+	(811 , happyReduce_811),+	(812 , happyReduce_812),+	(813 , happyReduce_813),+	(814 , happyReduce_814),+	(815 , happyReduce_815),+	(816 , happyReduce_816),+	(817 , happyReduce_817),+	(818 , happyReduce_818),+	(819 , happyReduce_819),+	(820 , happyReduce_820),+	(821 , happyReduce_821),+	(822 , happyReduce_822),+	(823 , happyReduce_823),+	(824 , happyReduce_824),+	(825 , happyReduce_825),+	(826 , happyReduce_826)+	]++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 )+happyReduce_13 = happySpecReduce_1  0# happyReduction_13+happyReduction_13 happy_x_1+	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> +	happyIn16+		 (happy_var_1+	)}++happyReduce_14 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_14 = happySpecReduce_1  0# happyReduction_14+happyReduction_14 happy_x_1+	 =  case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> +	happyIn16+		 (happy_var_1+	)}++happyReduce_15 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_15 = happySpecReduce_1  0# happyReduction_15+happyReduction_15 happy_x_1+	 =  case happyOut296 happy_x_1 of { (HappyWrap296 happy_var_1) -> +	happyIn16+		 (happy_var_1+	)}++happyReduce_16 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_16 = happySpecReduce_1  0# happyReduction_16+happyReduction_16 happy_x_1+	 =  case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> +	happyIn16+		 (happy_var_1+	)}++happyReduce_17 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_17 = happyMonadReduce 3# 0# happyReduction_17+happyReduction_17 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)+                               [mop happy_var_1,mu AnnRarrow happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn16 r))++happyReduce_18 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_18 = happySpecReduce_3  1# happyReduction_18+happyReduction_18 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> +	happyIn17+		 (fromOL happy_var_2+	)}++happyReduce_19 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_19 = happySpecReduce_3  1# happyReduction_19+happyReduction_19 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> +	happyIn17+		 (fromOL happy_var_2+	)}++happyReduce_20 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_20 = happySpecReduce_3  2# happyReduction_20+happyReduction_20 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut18 happy_x_1 of { (HappyWrap18 happy_var_1) -> +	case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> +	happyIn18+		 (happy_var_1 `appOL` unitOL happy_var_3+	)}}++happyReduce_21 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_21 = happySpecReduce_2  2# happyReduction_21+happyReduction_21 happy_x_2+	happy_x_1+	 =  case happyOut18 happy_x_1 of { (HappyWrap18 happy_var_1) -> +	happyIn18+		 (happy_var_1+	)}++happyReduce_22 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_22 = happySpecReduce_1  2# happyReduction_22+happyReduction_22 happy_x_1+	 =  case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> +	happyIn18+		 (unitOL happy_var_1+	)}++happyReduce_23 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_23 = happyReduce 4# 3# happyReduction_23+happyReduction_23 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut24 happy_x_2 of { (HappyWrap24 happy_var_2) -> +	case happyOut30 happy_x_4 of { (HappyWrap30 happy_var_4) -> +	happyIn19+		 (sL1 happy_var_1 $ HsUnit { hsunitName = happy_var_2+                              , hsunitBody = fromOL happy_var_4 }+	) `HappyStk` happyRest}}}++happyReduce_24 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_24 = happySpecReduce_1  4# happyReduction_24+happyReduction_24 happy_x_1+	 =  case happyOut24 happy_x_1 of { (HappyWrap24 happy_var_1) -> +	happyIn20+		 (sL1 happy_var_1 $ HsUnitId happy_var_1 []+	)}++happyReduce_25 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_25 = happyReduce 4# 4# happyReduction_25+happyReduction_25 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut24 happy_x_1 of { (HappyWrap24 happy_var_1) -> +	case happyOut21 happy_x_3 of { (HappyWrap21 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn20+		 (sLL happy_var_1 happy_var_4 $ HsUnitId happy_var_1 (fromOL happy_var_3)+	) `HappyStk` happyRest}}}++happyReduce_26 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_26 = happySpecReduce_3  5# happyReduction_26+happyReduction_26 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> +	case happyOut22 happy_x_3 of { (HappyWrap22 happy_var_3) -> +	happyIn21+		 (happy_var_1 `appOL` unitOL happy_var_3+	)}}++happyReduce_27 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_27 = happySpecReduce_2  5# happyReduction_27+happyReduction_27 happy_x_2+	happy_x_1+	 =  case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> +	happyIn21+		 (happy_var_1+	)}++happyReduce_28 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_28 = happySpecReduce_1  5# happyReduction_28+happyReduction_28 happy_x_1+	 =  case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> +	happyIn21+		 (unitOL happy_var_1+	)}++happyReduce_29 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_29 = happySpecReduce_3  6# happyReduction_29+happyReduction_29 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> +	case happyOut23 happy_x_3 of { (HappyWrap23 happy_var_3) -> +	happyIn22+		 (sLL happy_var_1 happy_var_3 $ (happy_var_1, happy_var_3)+	)}}++happyReduce_30 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_30 = happyReduce 4# 6# happyReduction_30+happyReduction_30 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn22+		 (sLL happy_var_1 happy_var_4 $ (happy_var_1, sLL happy_var_2 happy_var_4 $ HsModuleVar happy_var_3)+	) `HappyStk` happyRest}}}}++happyReduce_31 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_31 = happySpecReduce_3  7# happyReduction_31+happyReduction_31 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn23+		 (sLL happy_var_1 happy_var_3 $ HsModuleVar happy_var_2+	)}}}++happyReduce_32 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_32 = happySpecReduce_3  7# happyReduction_32+happyReduction_32 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut20 happy_x_1 of { (HappyWrap20 happy_var_1) -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	happyIn23+		 (sLL happy_var_1 happy_var_3 $ HsModuleId happy_var_1 happy_var_3+	)}}++happyReduce_33 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_33 = happySpecReduce_1  8# happyReduction_33+happyReduction_33 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn24+		 (sL1 happy_var_1 $ PackageName (getSTRING happy_var_1)+	)}++happyReduce_34 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_34 = happySpecReduce_1  8# happyReduction_34+happyReduction_34 happy_x_1+	 =  case happyOut26 happy_x_1 of { (HappyWrap26 happy_var_1) -> +	happyIn24+		 (sL1 happy_var_1 $ PackageName (unLoc happy_var_1)+	)}++happyReduce_35 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_35 = happySpecReduce_1  9# happyReduction_35+happyReduction_35 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn25+		 (sL1 happy_var_1 $ getVARID happy_var_1+	)}++happyReduce_36 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_36 = happySpecReduce_1  9# happyReduction_36+happyReduction_36 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn25+		 (sL1 happy_var_1 $ getCONID happy_var_1+	)}++happyReduce_37 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_37 = happySpecReduce_1  9# happyReduction_37+happyReduction_37 happy_x_1+	 =  case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> +	happyIn25+		 (happy_var_1+	)}++happyReduce_38 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_38 = happySpecReduce_1  10# happyReduction_38+happyReduction_38 happy_x_1+	 =  case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> +	happyIn26+		 (happy_var_1+	)}++happyReduce_39 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_39 = happySpecReduce_3  10# happyReduction_39+happyReduction_39 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> +	case happyOut26 happy_x_3 of { (HappyWrap26 happy_var_3) -> +	happyIn26+		 (sLL happy_var_1 happy_var_3 $ appendFS (unLoc happy_var_1) (consFS '-' (unLoc happy_var_3))+	)}}++happyReduce_40 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_40 = happySpecReduce_0  11# happyReduction_40+happyReduction_40  =  happyIn27+		 (Nothing+	)++happyReduce_41 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_41 = happySpecReduce_3  11# happyReduction_41+happyReduction_41 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut28 happy_x_2 of { (HappyWrap28 happy_var_2) -> +	happyIn27+		 (Just (fromOL happy_var_2)+	)}++happyReduce_42 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_42 = happySpecReduce_3  12# happyReduction_42+happyReduction_42 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> +	case happyOut29 happy_x_3 of { (HappyWrap29 happy_var_3) -> +	happyIn28+		 (happy_var_1 `appOL` unitOL happy_var_3+	)}}++happyReduce_43 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_43 = happySpecReduce_2  12# happyReduction_43+happyReduction_43 happy_x_2+	happy_x_1+	 =  case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> +	happyIn28+		 (happy_var_1+	)}++happyReduce_44 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_44 = happySpecReduce_1  12# happyReduction_44+happyReduction_44 happy_x_1+	 =  case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> +	happyIn28+		 (unitOL happy_var_1+	)}++happyReduce_45 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_45 = happySpecReduce_3  13# happyReduction_45+happyReduction_45 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	happyIn29+		 (sLL happy_var_1 happy_var_3 $ Renaming happy_var_1 (Just happy_var_3)+	)}}++happyReduce_46 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_46 = happySpecReduce_1  13# happyReduction_46+happyReduction_46 happy_x_1+	 =  case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> +	happyIn29+		 (sL1 happy_var_1    $ Renaming happy_var_1 Nothing+	)}++happyReduce_47 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_47 = happySpecReduce_3  14# happyReduction_47+happyReduction_47 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut31 happy_x_2 of { (HappyWrap31 happy_var_2) -> +	happyIn30+		 (happy_var_2+	)}++happyReduce_48 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_48 = happySpecReduce_3  14# happyReduction_48+happyReduction_48 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut31 happy_x_2 of { (HappyWrap31 happy_var_2) -> +	happyIn30+		 (happy_var_2+	)}++happyReduce_49 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_49 = happySpecReduce_3  15# happyReduction_49+happyReduction_49 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> +	case happyOut32 happy_x_3 of { (HappyWrap32 happy_var_3) -> +	happyIn31+		 (happy_var_1 `appOL` unitOL happy_var_3+	)}}++happyReduce_50 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_50 = happySpecReduce_2  15# happyReduction_50+happyReduction_50 happy_x_2+	happy_x_1+	 =  case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> +	happyIn31+		 (happy_var_1+	)}++happyReduce_51 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_51 = happySpecReduce_1  15# happyReduction_51+happyReduction_51 happy_x_1+	 =  case happyOut32 happy_x_1 of { (HappyWrap32 happy_var_1) -> +	happyIn31+		 (unitOL happy_var_1+	)}++happyReduce_52 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_52 = happyReduce 8# 16# happyReduction_52+happyReduction_52 (happy_x_8 `HappyStk`+	happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> +	case happyOut318 happy_x_4 of { (HappyWrap318 happy_var_4) -> +	case happyOut38 happy_x_5 of { (HappyWrap38 happy_var_5) -> +	case happyOut48 happy_x_6 of { (HappyWrap48 happy_var_6) -> +	case happyOut39 happy_x_8 of { (HappyWrap39 happy_var_8) -> +	happyIn32+		 (sL1 happy_var_2 $ DeclD+                 (case snd happy_var_3 of+                   False -> HsSrcFile+                   True  -> HsBootFile)+                 happy_var_4+                 (Just $ sL1 happy_var_2 (HsModule (Just happy_var_4) happy_var_6 (fst $ snd happy_var_8) (snd $ snd happy_var_8) happy_var_5 happy_var_1))+	) `HappyStk` happyRest}}}}}}}++happyReduce_53 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_53 = happyReduce 7# 16# happyReduction_53+happyReduction_53 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> +	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> +	case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> +	happyIn32+		 (sL1 happy_var_2 $ DeclD+                 HsigFile+                 happy_var_3+                 (Just $ sL1 happy_var_2 (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7) (snd $ snd happy_var_7) happy_var_4 happy_var_1))+	) `HappyStk` happyRest}}}}}}++happyReduce_54 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_54 = happyReduce 4# 16# happyReduction_54+happyReduction_54 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> +	case happyOut318 happy_x_4 of { (HappyWrap318 happy_var_4) -> +	happyIn32+		 (sL1 happy_var_2 $ DeclD (case snd happy_var_3 of+                   False -> HsSrcFile+                   True  -> HsBootFile) happy_var_4 Nothing+	) `HappyStk` happyRest}}}++happyReduce_55 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_55 = happySpecReduce_3  16# happyReduction_55+happyReduction_55 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	happyIn32+		 (sL1 happy_var_2 $ DeclD HsigFile happy_var_3 Nothing+	)}}++happyReduce_56 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_56 = happySpecReduce_3  16# happyReduction_56+happyReduction_56 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut20 happy_x_2 of { (HappyWrap20 happy_var_2) -> +	case happyOut27 happy_x_3 of { (HappyWrap27 happy_var_3) -> +	happyIn32+		 (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_2+                                              , idModRenaming = happy_var_3+                                              , idSignatureInclude = False })+	)}}}++happyReduce_57 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_57 = happySpecReduce_3  16# happyReduction_57+happyReduction_57 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> +	happyIn32+		 (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_3+                                              , idModRenaming = Nothing+                                              , idSignatureInclude = True })+	)}}++happyReduce_58 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_58 = happyMonadReduce 7# 17# happyReduction_58+happyReduction_58 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> +	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> +	( fileSrcSpan >>= \ loc ->+                ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)+                              (snd $ snd happy_var_7) happy_var_4 happy_var_1)+                    )+                    ([mj AnnSignature happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})+	) (\r -> happyReturn (happyIn33 r))++happyReduce_59 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_59 = happyMonadReduce 7# 18# happyReduction_59+happyReduction_59 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> +	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> +	( fileSrcSpan >>= \ loc ->+                ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)+                              (snd $ snd happy_var_7) happy_var_4 happy_var_1)+                    )+                    ([mj AnnModule happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})+	) (\r -> happyReturn (happyIn34 r))++happyReduce_60 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_60 = happyMonadReduce 1# 18# happyReduction_60+happyReduction_60 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut40 happy_x_1 of { (HappyWrap40 happy_var_1) -> +	( fileSrcSpan >>= \ loc ->+                   ams (L loc (HsModule Nothing Nothing+                               (fst $ snd happy_var_1) (snd $ snd happy_var_1) Nothing Nothing))+                       (fst happy_var_1))})+	) (\r -> happyReturn (happyIn34 r))++happyReduce_61 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_61 = happySpecReduce_1  19# happyReduction_61+happyReduction_61 happy_x_1+	 =  case happyOut326 happy_x_1 of { (HappyWrap326 happy_var_1) -> +	happyIn35+		 (happy_var_1+	)}++happyReduce_62 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_62 = happySpecReduce_0  19# happyReduction_62+happyReduction_62  =  happyIn35+		 (Nothing+	)++happyReduce_63 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_63 = happyMonadReduce 0# 20# happyReduction_63+happyReduction_63 (happyRest) tk+	 = happyThen ((( pushModuleContext))+	) (\r -> happyReturn (happyIn36 r))++happyReduce_64 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_64 = happyMonadReduce 0# 21# happyReduction_64+happyReduction_64 (happyRest) tk+	 = happyThen ((( pushModuleContext))+	) (\r -> happyReturn (happyIn37 r))++happyReduce_65 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_65 = happyMonadReduce 3# 22# happyReduction_65+happyReduction_65 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ajs (sLL happy_var_1 happy_var_3 $ DeprecatedTxt (sL1 happy_var_1 (getDEPRECATED_PRAGs happy_var_1)) (snd $ unLoc happy_var_2))+                             (mo happy_var_1:mc happy_var_3: (fst $ unLoc happy_var_2)))}}})+	) (\r -> happyReturn (happyIn38 r))++happyReduce_66 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_66 = happyMonadReduce 3# 22# happyReduction_66+happyReduction_66 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ajs (sLL happy_var_1 happy_var_3 $ WarningTxt (sL1 happy_var_1 (getWARNING_PRAGs happy_var_1)) (snd $ unLoc happy_var_2))+                                (mo happy_var_1:mc happy_var_3 : (fst $ unLoc happy_var_2)))}}})+	) (\r -> happyReturn (happyIn38 r))++happyReduce_67 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_67 = happySpecReduce_0  22# happyReduction_67+happyReduction_67  =  happyIn38+		 (Nothing+	)++happyReduce_68 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_68 = happySpecReduce_3  23# happyReduction_68+happyReduction_68 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn39+		 ((moc happy_var_1:mcc happy_var_3:(fst happy_var_2)+                                         , snd happy_var_2)+	)}}}++happyReduce_69 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_69 = happySpecReduce_3  23# happyReduction_69+happyReduction_69 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> +	happyIn39+		 ((fst happy_var_2, snd happy_var_2)+	)}++happyReduce_70 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_70 = happySpecReduce_3  24# happyReduction_70+happyReduction_70 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn40+		 ((moc happy_var_1:mcc happy_var_3+                                                   :(fst happy_var_2), snd happy_var_2)+	)}}}++happyReduce_71 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_71 = happySpecReduce_3  24# happyReduction_71+happyReduction_71 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> +	happyIn40+		 (([],snd happy_var_2)+	)}++happyReduce_72 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_72 = happySpecReduce_2  25# happyReduction_72+happyReduction_72 happy_x_2+	happy_x_1+	 =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> +	case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> +	happyIn41+		 ((happy_var_1, happy_var_2)+	)}}++happyReduce_73 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_73 = happySpecReduce_2  26# happyReduction_73+happyReduction_73 happy_x_2+	happy_x_1+	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> +	case happyOut76 happy_x_2 of { (HappyWrap76 happy_var_2) -> +	happyIn42+		 ((reverse happy_var_1, cvTopDecls happy_var_2)+	)}}++happyReduce_74 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_74 = happySpecReduce_2  26# happyReduction_74+happyReduction_74 happy_x_2+	happy_x_1+	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> +	case happyOut75 happy_x_2 of { (HappyWrap75 happy_var_2) -> +	happyIn42+		 ((reverse happy_var_1, cvTopDecls happy_var_2)+	)}}++happyReduce_75 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_75 = happySpecReduce_1  26# happyReduction_75+happyReduction_75 happy_x_1+	 =  case happyOut62 happy_x_1 of { (HappyWrap62 happy_var_1) -> +	happyIn42+		 ((reverse happy_var_1, [])+	)}++happyReduce_76 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_76 = happyMonadReduce 7# 27# happyReduction_76+happyReduction_76 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> +	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	case happyOut44 happy_x_7 of { (HappyWrap44 happy_var_7) -> +	( fileSrcSpan >>= \ loc ->+                   ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1+                          )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})+	) (\r -> happyReturn (happyIn43 r))++happyReduce_77 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_77 = happyMonadReduce 7# 27# happyReduction_77+happyReduction_77 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> +	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> +	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	case happyOut44 happy_x_7 of { (HappyWrap44 happy_var_7) -> +	( fileSrcSpan >>= \ loc ->+                   ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1+                          )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})+	) (\r -> happyReturn (happyIn43 r))++happyReduce_78 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_78 = happyMonadReduce 1# 27# happyReduction_78+happyReduction_78 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> +	( fileSrcSpan >>= \ loc ->+                   return (L loc (HsModule Nothing Nothing happy_var_1 [] Nothing+                          Nothing)))})+	) (\r -> happyReturn (happyIn43 r))++happyReduce_79 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_79 = happySpecReduce_2  28# happyReduction_79+happyReduction_79 happy_x_2+	happy_x_1+	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> +	happyIn44+		 (happy_var_2+	)}++happyReduce_80 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_80 = happySpecReduce_2  28# happyReduction_80+happyReduction_80 happy_x_2+	happy_x_1+	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> +	happyIn44+		 (happy_var_2+	)}++happyReduce_81 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_81 = happySpecReduce_2  29# happyReduction_81+happyReduction_81 happy_x_2+	happy_x_1+	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> +	happyIn45+		 (happy_var_2+	)}++happyReduce_82 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_82 = happySpecReduce_2  29# happyReduction_82+happyReduction_82 happy_x_2+	happy_x_1+	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> +	happyIn45+		 (happy_var_2+	)}++happyReduce_83 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_83 = happySpecReduce_2  30# happyReduction_83+happyReduction_83 happy_x_2+	happy_x_1+	 =  case happyOut47 happy_x_2 of { (HappyWrap47 happy_var_2) -> +	happyIn46+		 (happy_var_2+	)}++happyReduce_84 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_84 = happySpecReduce_1  31# happyReduction_84+happyReduction_84 happy_x_1+	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> +	happyIn47+		 (happy_var_1+	)}++happyReduce_85 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_85 = happySpecReduce_1  31# happyReduction_85+happyReduction_85 happy_x_1+	 =  case happyOut62 happy_x_1 of { (HappyWrap62 happy_var_1) -> +	happyIn47+		 (happy_var_1+	)}++happyReduce_86 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_86 = happyMonadReduce 3# 32# happyReduction_86+happyReduction_86 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( amsL (comb2 happy_var_1 happy_var_3) [mop happy_var_1,mcp happy_var_3] >>+                                       return (Just (sLL happy_var_1 happy_var_3 (fromOL happy_var_2))))}}})+	) (\r -> happyReturn (happyIn48 r))++happyReduce_87 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_87 = happySpecReduce_0  32# happyReduction_87+happyReduction_87  =  happyIn48+		 (Nothing+	)++happyReduce_88 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_88 = happyMonadReduce 3# 33# happyReduction_88+happyReduction_88 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> +	( addAnnotation (oll happy_var_1) AnnComma (gl happy_var_2)+                                         >> return (happy_var_1 `appOL` happy_var_3))}}})+	) (\r -> happyReturn (happyIn49 r))++happyReduce_89 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_89 = happySpecReduce_1  33# happyReduction_89+happyReduction_89 happy_x_1+	 =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> +	happyIn49+		 (happy_var_1+	)}++happyReduce_90 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_90 = happyMonadReduce 5# 34# happyReduction_90+happyReduction_90 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> +	case happyOut53 happy_x_2 of { (HappyWrap53 happy_var_2) -> +	case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut50 happy_x_5 of { (HappyWrap50 happy_var_5) -> +	( (addAnnotation (oll (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3))+                                            AnnComma (gl happy_var_4) ) >>+                              return (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3 `appOL` happy_var_5))}}}}})+	) (\r -> happyReturn (happyIn50 r))++happyReduce_91 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_91 = happySpecReduce_3  34# happyReduction_91+happyReduction_91 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> +	case happyOut53 happy_x_2 of { (HappyWrap53 happy_var_2) -> +	case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> +	happyIn50+		 (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3+	)}}}++happyReduce_92 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_92 = happySpecReduce_1  34# happyReduction_92+happyReduction_92 happy_x_1+	 =  case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> +	happyIn50+		 (happy_var_1+	)}++happyReduce_93 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_93 = happySpecReduce_2  35# happyReduction_93+happyReduction_93 happy_x_2+	happy_x_1+	 =  case happyOut52 happy_x_1 of { (HappyWrap52 happy_var_1) -> +	case happyOut51 happy_x_2 of { (HappyWrap51 happy_var_2) -> +	happyIn51+		 (happy_var_1 `appOL` happy_var_2+	)}}++happyReduce_94 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_94 = happySpecReduce_0  35# happyReduction_94+happyReduction_94  =  happyIn51+		 (nilOL+	)++happyReduce_95 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_95 = happySpecReduce_1  36# happyReduction_95+happyReduction_95 happy_x_1+	 =  case happyOut325 happy_x_1 of { (HappyWrap325 happy_var_1) -> +	happyIn52+		 (unitOL (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> IEGroup noExtField n doc))+	)}++happyReduce_96 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_96 = happySpecReduce_1  36# happyReduction_96+happyReduction_96 happy_x_1+	 =  case happyOut324 happy_x_1 of { (HappyWrap324 happy_var_1) -> +	happyIn52+		 (unitOL (sL1 happy_var_1 (IEDocNamed noExtField ((fst . unLoc) happy_var_1)))+	)}++happyReduce_97 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_97 = happySpecReduce_1  36# happyReduction_97+happyReduction_97 happy_x_1+	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> +	happyIn52+		 (unitOL (sL1 happy_var_1 (IEDoc noExtField (unLoc happy_var_1)))+	)}++happyReduce_98 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_98 = happyMonadReduce 2# 37# happyReduction_98+happyReduction_98 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> +	case happyOut54 happy_x_2 of { (HappyWrap54 happy_var_2) -> +	( mkModuleImpExp happy_var_1 (snd $ unLoc happy_var_2)+                                          >>= \ie -> amsu (sLL happy_var_1 happy_var_2 ie) (fst $ unLoc happy_var_2))}})+	) (\r -> happyReturn (happyIn53 r))++happyReduce_99 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_99 = happyMonadReduce 2# 37# happyReduction_99+happyReduction_99 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> +	( amsu (sLL happy_var_1 happy_var_2 (IEModuleContents noExtField happy_var_2))+                                             [mj AnnModule happy_var_1])}})+	) (\r -> happyReturn (happyIn53 r))++happyReduce_100 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_100 = happyMonadReduce 2# 37# happyReduction_100+happyReduction_100 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut273 happy_x_2 of { (HappyWrap273 happy_var_2) -> +	( amsu (sLL happy_var_1 happy_var_2 (IEVar noExtField (sLL happy_var_1 happy_var_2 (IEPattern happy_var_2))))+                                             [mj AnnPattern happy_var_1])}})+	) (\r -> happyReturn (happyIn53 r))++happyReduce_101 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_101 = happySpecReduce_0  38# happyReduction_101+happyReduction_101  =  happyIn54+		 (sL0 ([],ImpExpAbs)+	)++happyReduce_102 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_102 = happyMonadReduce 3# 38# happyReduction_102+happyReduction_102 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut55 happy_x_2 of { (HappyWrap55 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( mkImpExpSubSpec (reverse (snd happy_var_2))+                                      >>= \(as,ie) -> return $ sLL happy_var_1 happy_var_3+                                            (as ++ [mop happy_var_1,mcp happy_var_3] ++ fst happy_var_2, ie))}}})+	) (\r -> happyReturn (happyIn54 r))++happyReduce_103 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_103 = happySpecReduce_0  39# happyReduction_103+happyReduction_103  =  happyIn55+		 (([],[])+	)++happyReduce_104 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_104 = happySpecReduce_1  39# happyReduction_104+happyReduction_104 happy_x_1+	 =  case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> +	happyIn55+		 (happy_var_1+	)}++happyReduce_105 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_105 = happyMonadReduce 3# 40# happyReduction_105+happyReduction_105 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut57 happy_x_3 of { (HappyWrap57 happy_var_3) -> +	( case (head (snd happy_var_1)) of+                                                    l@(L _ ImpExpQcWildcard) ->+                                                       return ([mj AnnComma happy_var_2, mj AnnDotdot l]+                                                               ,(snd (unLoc happy_var_3)  : snd happy_var_1))+                                                    l -> (ams (head (snd happy_var_1)) [mj AnnComma happy_var_2] >>+                                                          return (fst happy_var_1 ++ fst (unLoc happy_var_3),+                                                                  snd (unLoc happy_var_3) : snd happy_var_1)))}}})+	) (\r -> happyReturn (happyIn56 r))++happyReduce_106 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_106 = happySpecReduce_1  40# happyReduction_106+happyReduction_106 happy_x_1+	 =  case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> +	happyIn56+		 ((fst (unLoc happy_var_1),[snd (unLoc happy_var_1)])+	)}++happyReduce_107 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_107 = happySpecReduce_1  41# happyReduction_107+happyReduction_107 happy_x_1+	 =  case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> +	happyIn57+		 (sL1 happy_var_1 ([],happy_var_1)+	)}++happyReduce_108 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_108 = happySpecReduce_1  41# happyReduction_108+happyReduction_108 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn57+		 (sL1 happy_var_1 ([mj AnnDotdot happy_var_1], sL1 happy_var_1 ImpExpQcWildcard)+	)}++happyReduce_109 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_109 = happySpecReduce_1  42# happyReduction_109+happyReduction_109 happy_x_1+	 =  case happyOut59 happy_x_1 of { (HappyWrap59 happy_var_1) -> +	happyIn58+		 (sL1 happy_var_1 (ImpExpQcName happy_var_1)+	)}++happyReduce_110 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_110 = happyMonadReduce 2# 42# happyReduction_110+happyReduction_110 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut283 happy_x_2 of { (HappyWrap283 happy_var_2) -> +	( do { n <- mkTypeImpExp happy_var_2+                                          ; ams (sLL happy_var_1 happy_var_2 (ImpExpQcType n))+                                                [mj AnnType happy_var_1] })}})+	) (\r -> happyReturn (happyIn58 r))++happyReduce_111 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_111 = happySpecReduce_1  43# happyReduction_111+happyReduction_111 happy_x_1+	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> +	happyIn59+		 (happy_var_1+	)}++happyReduce_112 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_112 = happySpecReduce_1  43# happyReduction_112+happyReduction_112 happy_x_1+	 =  case happyOut284 happy_x_1 of { (HappyWrap284 happy_var_1) -> +	happyIn59+		 (happy_var_1+	)}++happyReduce_113 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_113 = happySpecReduce_2  44# happyReduction_113+happyReduction_113 happy_x_2+	happy_x_1+	 =  case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn60+		 (mj AnnSemi happy_var_2 : happy_var_1+	)}}++happyReduce_114 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_114 = happySpecReduce_1  44# happyReduction_114+happyReduction_114 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn60+		 ([mj AnnSemi happy_var_1]+	)}++happyReduce_115 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_115 = happySpecReduce_2  45# happyReduction_115+happyReduction_115 happy_x_2+	happy_x_1+	 =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn61+		 (mj AnnSemi happy_var_2 : happy_var_1+	)}}++happyReduce_116 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_116 = happySpecReduce_0  45# happyReduction_116+happyReduction_116  =  happyIn61+		 ([]+	)++happyReduce_117 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_117 = happySpecReduce_2  46# happyReduction_117+happyReduction_117 happy_x_2+	happy_x_1+	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> +	case happyOut64 happy_x_2 of { (HappyWrap64 happy_var_2) -> +	happyIn62+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_118 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_118 = happyMonadReduce 3# 47# happyReduction_118+happyReduction_118 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> +	case happyOut64 happy_x_2 of { (HappyWrap64 happy_var_2) -> +	case happyOut60 happy_x_3 of { (HappyWrap60 happy_var_3) -> +	( ams happy_var_2 happy_var_3 >> return (happy_var_2 : happy_var_1))}}})+	) (\r -> happyReturn (happyIn63 r))++happyReduce_119 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_119 = happySpecReduce_0  47# happyReduction_119+happyReduction_119  =  happyIn63+		 ([]+	)++happyReduce_120 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_120 = happyMonadReduce 9# 48# happyReduction_120+happyReduction_120 (happy_x_9 `HappyStk`+	happy_x_8 `HappyStk`+	happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut65 happy_x_2 of { (HappyWrap65 happy_var_2) -> +	case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> +	case happyOut68 happy_x_4 of { (HappyWrap68 happy_var_4) -> +	case happyOut67 happy_x_5 of { (HappyWrap67 happy_var_5) -> +	case happyOut318 happy_x_6 of { (HappyWrap318 happy_var_6) -> +	case happyOut68 happy_x_7 of { (HappyWrap68 happy_var_7) -> +	case happyOut69 happy_x_8 of { (HappyWrap69 happy_var_8) -> +	case happyOut70 happy_x_9 of { (HappyWrap70 happy_var_9) -> +	( do {+                  ; checkImportDecl happy_var_4 happy_var_7+                  ; ams (L (comb4 happy_var_1 happy_var_6 (snd happy_var_8) happy_var_9) $+                      ImportDecl { ideclExt = noExtField+                                  , ideclSourceSrc = snd $ fst happy_var_2+                                  , ideclName = happy_var_6, ideclPkgQual = snd happy_var_5+                                  , ideclSource = snd happy_var_2, ideclSafe = snd happy_var_3+                                  , ideclQualified = importDeclQualifiedStyle happy_var_4 happy_var_7+                                  , ideclImplicit = False+                                  , ideclAs = unLoc (snd happy_var_8)+                                  , ideclHiding = unLoc happy_var_9 })+                         (mj AnnImport happy_var_1 : fst (fst happy_var_2) ++ fst happy_var_3 ++ fmap (mj AnnQualified) (maybeToList happy_var_4)+                                          ++ fst happy_var_5 ++ fmap (mj AnnQualified) (maybeToList happy_var_7) ++ fst happy_var_8)+                  })}}}}}}}}})+	) (\r -> happyReturn (happyIn64 r))++happyReduce_121 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_121 = happySpecReduce_2  49# happyReduction_121+happyReduction_121 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn65+		 ((([mo happy_var_1,mc happy_var_2],getSOURCE_PRAGs happy_var_1)+                                      , True)+	)}}++happyReduce_122 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_122 = happySpecReduce_0  49# happyReduction_122+happyReduction_122  =  happyIn65+		 ((([],NoSourceText),False)+	)++happyReduce_123 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_123 = happySpecReduce_1  50# happyReduction_123+happyReduction_123 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn66+		 (([mj AnnSafe happy_var_1],True)+	)}++happyReduce_124 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_124 = happySpecReduce_0  50# happyReduction_124+happyReduction_124  =  happyIn66+		 (([],False)+	)++happyReduce_125 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_125 = happyMonadReduce 1# 51# happyReduction_125+happyReduction_125 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( do { let { pkgFS = getSTRING happy_var_1 }+                        ; unless (looksLikePackageName (unpackFS pkgFS)) $+                             addError (getLoc happy_var_1) $ vcat [+                             text "Parse error" <> colon <+> quotes (ppr pkgFS),+                             text "Version number or non-alphanumeric" <+>+                             text "character in package name"]+                        ; return ([mj AnnPackageName happy_var_1], Just (StringLiteral (getSTRINGs happy_var_1) pkgFS)) })})+	) (\r -> happyReturn (happyIn67 r))++happyReduce_126 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_126 = happySpecReduce_0  51# happyReduction_126+happyReduction_126  =  happyIn67+		 (([],Nothing)+	)++happyReduce_127 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_127 = happySpecReduce_1  52# happyReduction_127+happyReduction_127 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn68+		 (Just happy_var_1+	)}++happyReduce_128 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_128 = happySpecReduce_0  52# happyReduction_128+happyReduction_128  =  happyIn68+		 (Nothing+	)++happyReduce_129 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_129 = happySpecReduce_2  53# happyReduction_129+happyReduction_129 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> +	happyIn69+		 (([mj AnnAs happy_var_1]+                                                 ,sLL happy_var_1 happy_var_2 (Just happy_var_2))+	)}}++happyReduce_130 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_130 = happySpecReduce_0  53# happyReduction_130+happyReduction_130  =  happyIn69+		 (([],noLoc Nothing)+	)++happyReduce_131 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_131 = happyMonadReduce 1# 54# happyReduction_131+happyReduction_131 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut71 happy_x_1 of { (HappyWrap71 happy_var_1) -> +	( let (b, ie) = unLoc happy_var_1 in+                                       checkImportSpec ie+                                        >>= \checkedIe ->+                                          return (L (gl happy_var_1) (Just (b, checkedIe))))})+	) (\r -> happyReturn (happyIn70 r))++happyReduce_132 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_132 = happySpecReduce_0  54# happyReduction_132+happyReduction_132  =  happyIn70+		 (noLoc Nothing+	)++happyReduce_133 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_133 = happyMonadReduce 3# 55# happyReduction_133+happyReduction_133 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (False,+                                                      sLL happy_var_1 happy_var_3 $ fromOL happy_var_2))+                                                   [mop happy_var_1,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn71 r))++happyReduce_134 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_134 = happyMonadReduce 4# 55# happyReduction_134+happyReduction_134 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut49 happy_x_3 of { (HappyWrap49 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( ams (sLL happy_var_1 happy_var_4 (True,+                                                      sLL happy_var_1 happy_var_4 $ fromOL happy_var_3))+                                               [mj AnnHiding happy_var_1,mop happy_var_2,mcp happy_var_4])}}}})+	) (\r -> happyReturn (happyIn71 r))++happyReduce_135 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_135 = happySpecReduce_0  56# happyReduction_135+happyReduction_135  =  happyIn72+		 (noLoc (NoSourceText,9)+	)++happyReduce_136 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_136 = happySpecReduce_1  56# happyReduction_136+happyReduction_136 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn72+		 (sL1 happy_var_1 (getINTEGERs happy_var_1,fromInteger (il_value (getINTEGER happy_var_1)))+	)}++happyReduce_137 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_137 = happySpecReduce_1  57# happyReduction_137+happyReduction_137 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn73+		 (sL1 happy_var_1 InfixN+	)}++happyReduce_138 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_138 = happySpecReduce_1  57# happyReduction_138+happyReduction_138 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn73+		 (sL1 happy_var_1 InfixL+	)}++happyReduce_139 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_139 = happySpecReduce_1  57# happyReduction_139+happyReduction_139 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn73+		 (sL1 happy_var_1 InfixR+	)}++happyReduce_140 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_140 = happyMonadReduce 3# 58# happyReduction_140+happyReduction_140 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut291 happy_x_3 of { (HappyWrap291 happy_var_3) -> +	( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+                              return (sLL happy_var_1 happy_var_3 ((unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})+	) (\r -> happyReturn (happyIn74 r))++happyReduce_141 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_141 = happySpecReduce_1  58# happyReduction_141+happyReduction_141 happy_x_1+	 =  case happyOut291 happy_x_1 of { (HappyWrap291 happy_var_1) -> +	happyIn74+		 (sL1 happy_var_1 (unitOL happy_var_1)+	)}++happyReduce_142 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_142 = happySpecReduce_2  59# happyReduction_142+happyReduction_142 happy_x_2+	happy_x_1+	 =  case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> +	case happyOut77 happy_x_2 of { (HappyWrap77 happy_var_2) -> +	happyIn75+		 (happy_var_1 `snocOL` happy_var_2+	)}}++happyReduce_143 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_143 = happyMonadReduce 3# 60# happyReduction_143+happyReduction_143 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> +	case happyOut77 happy_x_2 of { (HappyWrap77 happy_var_2) -> +	case happyOut60 happy_x_3 of { (HappyWrap60 happy_var_3) -> +	( ams happy_var_2 happy_var_3 >> return (happy_var_1 `snocOL` happy_var_2))}}})+	) (\r -> happyReturn (happyIn76 r))++happyReduce_144 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_144 = happySpecReduce_0  60# happyReduction_144+happyReduction_144  =  happyIn76+		 (nilOL+	)++happyReduce_145 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_145 = happySpecReduce_1  61# happyReduction_145+happyReduction_145 happy_x_1+	 =  case happyOut78 happy_x_1 of { (HappyWrap78 happy_var_1) -> +	happyIn77+		 (sL1 happy_var_1 (TyClD noExtField (unLoc happy_var_1))+	)}++happyReduce_146 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_146 = happySpecReduce_1  61# happyReduction_146+happyReduction_146 happy_x_1+	 =  case happyOut79 happy_x_1 of { (HappyWrap79 happy_var_1) -> +	happyIn77+		 (sL1 happy_var_1 (TyClD noExtField (unLoc happy_var_1))+	)}++happyReduce_147 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_147 = happySpecReduce_1  61# happyReduction_147+happyReduction_147 happy_x_1+	 =  case happyOut80 happy_x_1 of { (HappyWrap80 happy_var_1) -> +	happyIn77+		 (sL1 happy_var_1 (KindSigD noExtField (unLoc happy_var_1))+	)}++happyReduce_148 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_148 = happySpecReduce_1  61# happyReduction_148+happyReduction_148 happy_x_1+	 =  case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> +	happyIn77+		 (sL1 happy_var_1 (InstD noExtField (unLoc happy_var_1))+	)}++happyReduce_149 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_149 = happySpecReduce_1  61# happyReduction_149+happyReduction_149 happy_x_1+	 =  case happyOut106 happy_x_1 of { (HappyWrap106 happy_var_1) -> +	happyIn77+		 (sLL happy_var_1 happy_var_1 (DerivD noExtField (unLoc happy_var_1))+	)}++happyReduce_150 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_150 = happySpecReduce_1  61# happyReduction_150+happyReduction_150 happy_x_1+	 =  case happyOut107 happy_x_1 of { (HappyWrap107 happy_var_1) -> +	happyIn77+		 (sL1 happy_var_1 (RoleAnnotD noExtField (unLoc happy_var_1))+	)}++happyReduce_151 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_151 = happyMonadReduce 4# 61# happyReduction_151+happyReduction_151 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut173 happy_x_3 of { (HappyWrap173 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( ams (sLL happy_var_1 happy_var_4 (DefD noExtField (DefaultDecl noExtField happy_var_3)))+                                                         [mj AnnDefault happy_var_1+                                                         ,mop happy_var_2,mcp happy_var_4])}}}})+	) (\r -> happyReturn (happyIn77 r))++happyReduce_152 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_152 = happyMonadReduce 2# 61# happyReduction_152+happyReduction_152 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut144 happy_x_2 of { (HappyWrap144 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 (snd $ unLoc happy_var_2))+                                           (mj AnnForeign happy_var_1:(fst $ unLoc happy_var_2)))}})+	) (\r -> happyReturn (happyIn77 r))++happyReduce_153 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_153 = happyMonadReduce 3# 61# happyReduction_153+happyReduction_153 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut139 happy_x_2 of { (HappyWrap139 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ WarningD noExtField (Warnings noExtField (getDEPRECATED_PRAGs happy_var_1) (fromOL happy_var_2)))+                                                       [mo happy_var_1,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn77 r))++happyReduce_154 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_154 = happyMonadReduce 3# 61# happyReduction_154+happyReduction_154 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut137 happy_x_2 of { (HappyWrap137 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ WarningD noExtField (Warnings noExtField (getWARNING_PRAGs happy_var_1) (fromOL happy_var_2)))+                                                       [mo happy_var_1,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn77 r))++happyReduce_155 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_155 = happyMonadReduce 3# 61# happyReduction_155+happyReduction_155 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut129 happy_x_2 of { (HappyWrap129 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ RuleD noExtField (HsRules noExtField (getRULES_PRAGs happy_var_1) (fromOL happy_var_2)))+                                                       [mo happy_var_1,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn77 r))++happyReduce_156 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_156 = happySpecReduce_1  61# happyReduction_156+happyReduction_156 happy_x_1+	 =  case happyOut143 happy_x_1 of { (HappyWrap143 happy_var_1) -> +	happyIn77+		 (happy_var_1+	)}++happyReduce_157 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_157 = happySpecReduce_1  61# happyReduction_157+happyReduction_157 happy_x_1+	 =  case happyOut201 happy_x_1 of { (HappyWrap201 happy_var_1) -> +	happyIn77+		 (happy_var_1+	)}++happyReduce_158 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_158 = happyMonadReduce 1# 61# happyReduction_158+happyReduction_158 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                                   return $ sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1)})+	) (\r -> happyReturn (happyIn77 r))++happyReduce_159 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_159 = happyMonadReduce 4# 62# happyReduction_159+happyReduction_159 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut103 happy_x_2 of { (HappyWrap103 happy_var_2) -> +	case happyOut178 happy_x_3 of { (HappyWrap178 happy_var_3) -> +	case happyOut120 happy_x_4 of { (HappyWrap120 happy_var_4) -> +	( amms (mkClassDecl (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4) happy_var_2 happy_var_3 (snd $ unLoc happy_var_4))+                        (mj AnnClass happy_var_1:(fst $ unLoc happy_var_3)++(fst $ unLoc happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn78 r))++happyReduce_160 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_160 = happyMonadReduce 4# 63# happyReduction_160+happyReduction_160 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut157 happy_x_4 of { (HappyWrap157 happy_var_4) -> +	( amms (mkTySynonym (comb2 happy_var_1 happy_var_4) happy_var_2 happy_var_4)+                        [mj AnnType happy_var_1,mj AnnEqual happy_var_3])}}}})+	) (\r -> happyReturn (happyIn79 r))++happyReduce_161 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_161 = happyMonadReduce 6# 63# happyReduction_161+happyReduction_161 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	case happyOut101 happy_x_4 of { (HappyWrap101 happy_var_4) -> +	case happyOut87 happy_x_5 of { (HappyWrap87 happy_var_5) -> +	case happyOut90 happy_x_6 of { (HappyWrap90 happy_var_6) -> +	( amms (mkFamDecl (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_6) happy_var_3+                                   (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5))+                        (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)+                           ++ (fst $ unLoc happy_var_5) ++ (fst $ unLoc happy_var_6)))}}}}}})+	) (\r -> happyReturn (happyIn79 r))++happyReduce_162 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_162 = happyMonadReduce 5# 63# happyReduction_162+happyReduction_162 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> +	case happyOut105 happy_x_2 of { (HappyWrap105 happy_var_2) -> +	case happyOut103 happy_x_3 of { (HappyWrap103 happy_var_3) -> +	case happyOut187 happy_x_4 of { (HappyWrap187 happy_var_4) -> +	case happyOut195 happy_x_5 of { (HappyWrap195 happy_var_5) -> +	( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3+                           Nothing (reverse (snd $ unLoc happy_var_4))+                                   (fmap reverse happy_var_5))+                                   -- We need the location on tycl_hdr in case+                                   -- constrs and deriving are both empty+                        ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})+	) (\r -> happyReturn (happyIn79 r))++happyReduce_163 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_163 = happyMonadReduce 6# 63# happyReduction_163+happyReduction_163 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> +	case happyOut105 happy_x_2 of { (HappyWrap105 happy_var_2) -> +	case happyOut103 happy_x_3 of { (HappyWrap103 happy_var_3) -> +	case happyOut99 happy_x_4 of { (HappyWrap99 happy_var_4) -> +	case happyOut183 happy_x_5 of { (HappyWrap183 happy_var_5) -> +	case happyOut195 happy_x_6 of { (HappyWrap195 happy_var_6) -> +	( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3+                            (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)+                            (fmap reverse happy_var_6) )+                                   -- We need the location on tycl_hdr in case+                                   -- constrs and deriving are both empty+                    ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})+	) (\r -> happyReturn (happyIn79 r))++happyReduce_164 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_164 = happyMonadReduce 4# 63# happyReduction_164+happyReduction_164 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	case happyOut100 happy_x_4 of { (HappyWrap100 happy_var_4) -> +	( amms (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_4) DataFamily happy_var_3+                                   (snd $ unLoc happy_var_4) Nothing)+                        (mj AnnData happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn79 r))++happyReduce_165 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_165 = happyMonadReduce 4# 64# happyReduction_165+happyReduction_165 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut81 happy_x_2 of { (HappyWrap81 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut157 happy_x_4 of { (HappyWrap157 happy_var_4) -> +	( amms (mkStandaloneKindSig (comb2 happy_var_1 happy_var_4) happy_var_2 happy_var_4)+              [mj AnnType happy_var_1,mu AnnDcolon happy_var_3])}}}})+	) (\r -> happyReturn (happyIn80 r))++happyReduce_166 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_166 = happyMonadReduce 3# 65# happyReduction_166+happyReduction_166 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut81 happy_x_1 of { (HappyWrap81 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut283 happy_x_3 of { (HappyWrap283 happy_var_3) -> +	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+         return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+	) (\r -> happyReturn (happyIn81 r))++happyReduce_167 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_167 = happySpecReduce_1  65# happyReduction_167+happyReduction_167 happy_x_1+	 =  case happyOut283 happy_x_1 of { (HappyWrap283 happy_var_1) -> +	happyIn81+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_168 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_168 = happyMonadReduce 4# 66# happyReduction_168+happyReduction_168 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut83 happy_x_2 of { (HappyWrap83 happy_var_2) -> +	case happyOut171 happy_x_3 of { (HappyWrap171 happy_var_3) -> +	case happyOut124 happy_x_4 of { (HappyWrap124 happy_var_4) -> +	( do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc happy_var_4)+             ; let cid = ClsInstDecl { cid_ext = noExtField+                                     , cid_poly_ty = happy_var_3, cid_binds = binds+                                     , cid_sigs = mkClassOpSigs sigs+                                     , cid_tyfam_insts = ats+                                     , cid_overlap_mode = happy_var_2+                                     , cid_datafam_insts = adts }+             ; ams (L (comb3 happy_var_1 (hsSigType happy_var_3) happy_var_4) (ClsInstD { cid_d_ext = noExtField, cid_inst = cid }))+                   (mj AnnInstance happy_var_1 : (fst $ unLoc happy_var_4)) })}}}})+	) (\r -> happyReturn (happyIn82 r))++happyReduce_169 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_169 = happyMonadReduce 3# 66# happyReduction_169+happyReduction_169 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> +	( ams happy_var_3 (fst $ unLoc happy_var_3)+                >> amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))+                    (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn82 r))++happyReduce_170 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_170 = happyMonadReduce 6# 66# happyReduction_170+happyReduction_170 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> +	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> +	case happyOut187 happy_x_5 of { (HappyWrap187 happy_var_5) -> +	case happyOut195 happy_x_6 of { (HappyWrap195 happy_var_6) -> +	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 (snd $ unLoc happy_var_4)+                                      Nothing (reverse (snd  $ unLoc happy_var_5))+                                              (fmap reverse happy_var_6))+                    ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})+	) (\r -> happyReturn (happyIn82 r))++happyReduce_171 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_171 = happyMonadReduce 7# 66# happyReduction_171+happyReduction_171 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> +	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> +	case happyOut99 happy_x_5 of { (HappyWrap99 happy_var_5) -> +	case happyOut183 happy_x_6 of { (HappyWrap183 happy_var_6) -> +	case happyOut195 happy_x_7 of { (HappyWrap195 happy_var_7) -> +	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3 (snd $ unLoc happy_var_4)+                                   (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)+                                   (fmap reverse happy_var_7))+                    ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2+                       :(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})+	) (\r -> happyReturn (happyIn82 r))++happyReduce_172 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_172 = happyMonadReduce 2# 67# happyReduction_172+happyReduction_172 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ajs (sLL happy_var_1 happy_var_2 (Overlappable (getOVERLAPPABLE_PRAGs happy_var_1)))+                                       [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn83 r))++happyReduce_173 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_173 = happyMonadReduce 2# 67# happyReduction_173+happyReduction_173 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ajs (sLL happy_var_1 happy_var_2 (Overlapping (getOVERLAPPING_PRAGs happy_var_1)))+                                       [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn83 r))++happyReduce_174 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_174 = happyMonadReduce 2# 67# happyReduction_174+happyReduction_174 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ajs (sLL happy_var_1 happy_var_2 (Overlaps (getOVERLAPS_PRAGs happy_var_1)))+                                       [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn83 r))++happyReduce_175 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_175 = happyMonadReduce 2# 67# happyReduction_175+happyReduction_175 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ajs (sLL happy_var_1 happy_var_2 (Incoherent (getINCOHERENT_PRAGs happy_var_1)))+                                       [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn83 r))++happyReduce_176 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_176 = happySpecReduce_0  67# happyReduction_176+happyReduction_176  =  happyIn83+		 (Nothing+	)++happyReduce_177 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_177 = happyMonadReduce 1# 68# happyReduction_177+happyReduction_177 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( ams (sL1 happy_var_1 StockStrategy)+                                       [mj AnnStock happy_var_1])})+	) (\r -> happyReturn (happyIn84 r))++happyReduce_178 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_178 = happyMonadReduce 1# 68# happyReduction_178+happyReduction_178 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( ams (sL1 happy_var_1 AnyclassStrategy)+                                       [mj AnnAnyclass happy_var_1])})+	) (\r -> happyReturn (happyIn84 r))++happyReduce_179 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_179 = happyMonadReduce 1# 68# happyReduction_179+happyReduction_179 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( ams (sL1 happy_var_1 NewtypeStrategy)+                                       [mj AnnNewtype happy_var_1])})+	) (\r -> happyReturn (happyIn84 r))++happyReduce_180 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_180 = happyMonadReduce 2# 69# happyReduction_180+happyReduction_180 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 (ViaStrategy (mkLHsSigType happy_var_2)))+                                            [mj AnnVia happy_var_1])}})+	) (\r -> happyReturn (happyIn85 r))++happyReduce_181 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_181 = happyMonadReduce 1# 70# happyReduction_181+happyReduction_181 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( ajs (sL1 happy_var_1 StockStrategy)+                                       [mj AnnStock happy_var_1])})+	) (\r -> happyReturn (happyIn86 r))++happyReduce_182 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_182 = happyMonadReduce 1# 70# happyReduction_182+happyReduction_182 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( ajs (sL1 happy_var_1 AnyclassStrategy)+                                       [mj AnnAnyclass happy_var_1])})+	) (\r -> happyReturn (happyIn86 r))++happyReduce_183 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_183 = happyMonadReduce 1# 70# happyReduction_183+happyReduction_183 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( ajs (sL1 happy_var_1 NewtypeStrategy)+                                       [mj AnnNewtype happy_var_1])})+	) (\r -> happyReturn (happyIn86 r))++happyReduce_184 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_184 = happySpecReduce_1  70# happyReduction_184+happyReduction_184 happy_x_1+	 =  case happyOut85 happy_x_1 of { (HappyWrap85 happy_var_1) -> +	happyIn86+		 (Just happy_var_1+	)}++happyReduce_185 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_185 = happySpecReduce_0  70# happyReduction_185+happyReduction_185  =  happyIn86+		 (Nothing+	)++happyReduce_186 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_186 = happySpecReduce_0  71# happyReduction_186+happyReduction_186  =  happyIn87+		 (noLoc ([], Nothing)+	)++happyReduce_187 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_187 = happySpecReduce_2  71# happyReduction_187+happyReduction_187 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut88 happy_x_2 of { (HappyWrap88 happy_var_2) -> +	happyIn87+		 (sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]+                                                , Just (happy_var_2))+	)}}++happyReduce_188 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_188 = happyMonadReduce 3# 72# happyReduction_188+happyReduction_188 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut89 happy_x_3 of { (HappyWrap89 happy_var_3) -> +	( ams (sLL happy_var_1 happy_var_3 (InjectivityAnn happy_var_1 (reverse (unLoc happy_var_3))))+                  [mu AnnRarrow happy_var_2])}}})+	) (\r -> happyReturn (happyIn88 r))++happyReduce_189 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_189 = happySpecReduce_2  73# happyReduction_189+happyReduction_189 happy_x_2+	happy_x_1+	 =  case happyOut89 happy_x_1 of { (HappyWrap89 happy_var_1) -> +	case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> +	happyIn89+		 (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+	)}}++happyReduce_190 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_190 = happySpecReduce_1  73# happyReduction_190+happyReduction_190 happy_x_1+	 =  case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> +	happyIn89+		 (sLL happy_var_1 happy_var_1 [happy_var_1]+	)}++happyReduce_191 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_191 = happySpecReduce_0  74# happyReduction_191+happyReduction_191  =  happyIn90+		 (noLoc ([],OpenTypeFamily)+	)++happyReduce_192 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_192 = happySpecReduce_2  74# happyReduction_192+happyReduction_192 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut91 happy_x_2 of { (HappyWrap91 happy_var_2) -> +	happyIn90+		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)+                    ,ClosedTypeFamily (fmap reverse $ snd $ unLoc happy_var_2))+	)}}++happyReduce_193 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_193 = happySpecReduce_3  75# happyReduction_193+happyReduction_193 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut92 happy_x_2 of { (HappyWrap92 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn91+		 (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]+                                                ,Just (unLoc happy_var_2))+	)}}}++happyReduce_194 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_194 = happySpecReduce_3  75# happyReduction_194+happyReduction_194 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut92 happy_x_2 of { (HappyWrap92 happy_var_2) -> +	happyIn91+		 (let (L loc _) = happy_var_2 in+                                             L loc ([],Just (unLoc happy_var_2))+	)}++happyReduce_195 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_195 = happySpecReduce_3  75# happyReduction_195+happyReduction_195 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn91+		 (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mj AnnDotdot happy_var_2+                                                 ,mcc happy_var_3],Nothing)+	)}}}++happyReduce_196 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_196 = happySpecReduce_3  75# happyReduction_196+happyReduction_196 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn91+		 (let (L loc _) = happy_var_2 in+                                             L loc ([mj AnnDotdot happy_var_2],Nothing)+	)}++happyReduce_197 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_197 = happyMonadReduce 3# 76# happyReduction_197+happyReduction_197 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut92 happy_x_1 of { (HappyWrap92 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> +	( let (L loc (anns, eqn)) = happy_var_3 in+                                         asl (unLoc happy_var_1) happy_var_2 (L loc eqn)+                                         >> ams happy_var_3 anns+                                         >> return (sLL happy_var_1 happy_var_3 (L loc eqn : unLoc happy_var_1)))}}})+	) (\r -> happyReturn (happyIn92 r))++happyReduce_198 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_198 = happyMonadReduce 2# 76# happyReduction_198+happyReduction_198 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut92 happy_x_1 of { (HappyWrap92 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)+                                         >> return (sLL happy_var_1 happy_var_2  (unLoc happy_var_1)))}})+	) (\r -> happyReturn (happyIn92 r))++happyReduce_199 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_199 = happyMonadReduce 1# 76# happyReduction_199+happyReduction_199 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut93 happy_x_1 of { (HappyWrap93 happy_var_1) -> +	( let (L loc (anns, eqn)) = happy_var_1 in+                                         ams happy_var_1 anns+                                         >> return (sLL happy_var_1 happy_var_1 [L loc eqn]))})+	) (\r -> happyReturn (happyIn92 r))++happyReduce_200 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_200 = happySpecReduce_0  76# happyReduction_200+happyReduction_200  =  happyIn92+		 (noLoc []+	)++happyReduce_201 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_201 = happyMonadReduce 6# 77# happyReduction_201+happyReduction_201 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut162 happy_x_4 of { (HappyWrap162 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	case happyOut156 happy_x_6 of { (HappyWrap156 happy_var_6) -> +	( do { hintExplicitForall happy_var_1+                    ; (eqn,ann) <- mkTyFamInstEqn (Just happy_var_2) happy_var_4 happy_var_6+                    ; return (sLL happy_var_1 happy_var_6+                               (mu AnnForall happy_var_1:mj AnnDot happy_var_3:mj AnnEqual happy_var_5:ann,eqn)) })}}}}}})+	) (\r -> happyReturn (happyIn93 r))++happyReduce_202 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_202 = happyMonadReduce 3# 77# happyReduction_202+happyReduction_202 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { (HappyWrap156 happy_var_3) -> +	( do { (eqn,ann) <- mkTyFamInstEqn Nothing happy_var_1 happy_var_3+                    ; return (sLL happy_var_1 happy_var_3 (mj AnnEqual happy_var_2:ann, eqn))  })}}})+	) (\r -> happyReturn (happyIn93 r))++happyReduce_203 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_203 = happyMonadReduce 4# 78# happyReduction_203+happyReduction_203 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut95 happy_x_2 of { (HappyWrap95 happy_var_2) -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	case happyOut100 happy_x_4 of { (HappyWrap100 happy_var_4) -> +	( amms (liftM mkTyClD (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) DataFamily happy_var_3+                                                  (snd $ unLoc happy_var_4) Nothing))+                        (mj AnnData happy_var_1:happy_var_2++(fst $ unLoc happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn94 r))++happyReduce_204 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_204 = happyMonadReduce 3# 78# happyReduction_204+happyReduction_204 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> +	case happyOut102 happy_x_3 of { (HappyWrap102 happy_var_3) -> +	( amms (liftM mkTyClD+                        (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_3) OpenTypeFamily happy_var_2+                                   (fst . snd $ unLoc happy_var_3)+                                   (snd . snd $ unLoc happy_var_3)))+                       (mj AnnType happy_var_1:(fst $ unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn94 r))++happyReduce_205 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_205 = happyMonadReduce 4# 78# happyReduction_205+happyReduction_205 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	case happyOut102 happy_x_4 of { (HappyWrap102 happy_var_4) -> +	( amms (liftM mkTyClD+                        (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) OpenTypeFamily happy_var_3+                                   (fst . snd $ unLoc happy_var_4)+                                   (snd . snd $ unLoc happy_var_4)))+                       (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn94 r))++happyReduce_206 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_206 = happyMonadReduce 2# 78# happyReduction_206+happyReduction_206 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut93 happy_x_2 of { (HappyWrap93 happy_var_2) -> +	( ams happy_var_2 (fst $ unLoc happy_var_2) >>+                   amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_2) (snd $ unLoc happy_var_2)))+                        (mj AnnType happy_var_1:(fst $ unLoc happy_var_2)))}})+	) (\r -> happyReturn (happyIn94 r))++happyReduce_207 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_207 = happyMonadReduce 3# 78# happyReduction_207+happyReduction_207 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> +	( ams happy_var_3 (fst $ unLoc happy_var_3) >>+                   amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3)))+                        (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn94 r))++happyReduce_208 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_208 = happySpecReduce_0  79# happyReduction_208+happyReduction_208  =  happyIn95+		 ([]+	)++happyReduce_209 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_209 = happySpecReduce_1  79# happyReduction_209+happyReduction_209 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn95+		 ([mj AnnFamily happy_var_1]+	)}++happyReduce_210 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_210 = happySpecReduce_0  80# happyReduction_210+happyReduction_210  =  happyIn96+		 ([]+	)++happyReduce_211 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_211 = happySpecReduce_1  80# happyReduction_211+happyReduction_211 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn96+		 ([mj AnnInstance happy_var_1]+	)}++happyReduce_212 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_212 = happyMonadReduce 3# 81# happyReduction_212+happyReduction_212 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> +	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> +	( ams happy_var_3 (fst $ unLoc happy_var_3) >>+                   amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))+                        (mj AnnType happy_var_1:happy_var_2++(fst $ unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn97 r))++happyReduce_213 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_213 = happyMonadReduce 6# 81# happyReduction_213+happyReduction_213 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> +	case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> +	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> +	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> +	case happyOut187 happy_x_5 of { (HappyWrap187 happy_var_5) -> +	case happyOut195 happy_x_6 of { (HappyWrap195 happy_var_6) -> +	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 (snd $ unLoc happy_var_4)+                                    Nothing (reverse (snd $ unLoc happy_var_5))+                                            (fmap reverse happy_var_6))+                       ((fst $ unLoc happy_var_1):happy_var_2++(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})+	) (\r -> happyReturn (happyIn97 r))++happyReduce_214 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_214 = happyMonadReduce 7# 81# happyReduction_214+happyReduction_214 (happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> +	case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> +	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> +	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> +	case happyOut99 happy_x_5 of { (HappyWrap99 happy_var_5) -> +	case happyOut183 happy_x_6 of { (HappyWrap183 happy_var_6) -> +	case happyOut195 happy_x_7 of { (HappyWrap195 happy_var_7) -> +	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3+                                (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)+                                (fmap reverse happy_var_7))+                        ((fst $ unLoc happy_var_1):happy_var_2++(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})+	) (\r -> happyReturn (happyIn97 r))++happyReduce_215 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_215 = happySpecReduce_1  82# happyReduction_215+happyReduction_215 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn98+		 (sL1 happy_var_1 (mj AnnData    happy_var_1,DataType)+	)}++happyReduce_216 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_216 = happySpecReduce_1  82# happyReduction_216+happyReduction_216 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn98+		 (sL1 happy_var_1 (mj AnnNewtype happy_var_1,NewType)+	)}++happyReduce_217 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_217 = happySpecReduce_0  83# happyReduction_217+happyReduction_217  =  happyIn99+		 (noLoc     ([]               , Nothing)+	)++happyReduce_218 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_218 = happySpecReduce_2  83# happyReduction_218+happyReduction_218 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> +	happyIn99+		 (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], Just happy_var_2)+	)}}++happyReduce_219 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_219 = happySpecReduce_0  84# happyReduction_219+happyReduction_219  =  happyIn100+		 (noLoc     ([]               , noLoc (NoSig noExtField)         )+	)++happyReduce_220 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_220 = happySpecReduce_2  84# happyReduction_220+happyReduction_220 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> +	happyIn100+		 (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig noExtField happy_var_2))+	)}}++happyReduce_221 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_221 = happySpecReduce_0  85# happyReduction_221+happyReduction_221  =  happyIn101+		 (noLoc     ([]               , noLoc     (NoSig    noExtField)   )+	)++happyReduce_222 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_222 = happySpecReduce_2  85# happyReduction_222+happyReduction_222 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> +	happyIn101+		 (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig  noExtField happy_var_2))+	)}}++happyReduce_223 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_223 = happySpecReduce_2  85# happyReduction_223+happyReduction_223 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut177 happy_x_2 of { (HappyWrap177 happy_var_2) -> +	happyIn101+		 (sLL happy_var_1 happy_var_2 ([mj AnnEqual happy_var_1] , sLL happy_var_1 happy_var_2 (TyVarSig noExtField happy_var_2))+	)}}++happyReduce_224 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_224 = happySpecReduce_0  86# happyReduction_224+happyReduction_224  =  happyIn102+		 (noLoc ([], (noLoc (NoSig noExtField), Nothing))+	)++happyReduce_225 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_225 = happySpecReduce_2  86# happyReduction_225+happyReduction_225 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> +	happyIn102+		 (sLL happy_var_1 happy_var_2 ( [mu AnnDcolon happy_var_1]+                                 , (sLL happy_var_2 happy_var_2 (KindSig noExtField happy_var_2), Nothing))+	)}}++happyReduce_226 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_226 = happyReduce 4# 86# happyReduction_226+happyReduction_226 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut177 happy_x_2 of { (HappyWrap177 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut88 happy_x_4 of { (HappyWrap88 happy_var_4) -> +	happyIn102+		 (sLL happy_var_1 happy_var_4 ([mj AnnEqual happy_var_1, mj AnnVbar happy_var_3]+                            , (sLL happy_var_1 happy_var_2 (TyVarSig noExtField happy_var_2), Just happy_var_4))+	) `HappyStk` happyRest}}}}++happyReduce_227 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_227 = happyMonadReduce 3# 87# happyReduction_227+happyReduction_227 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+                                       >> (return (sLL happy_var_1 happy_var_3 (Just happy_var_1, happy_var_3))))}}})+	) (\r -> happyReturn (happyIn103 r))++happyReduce_228 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_228 = happySpecReduce_1  87# happyReduction_228+happyReduction_228 happy_x_1+	 =  case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> +	happyIn103+		 (sL1 happy_var_1 (Nothing, happy_var_1)+	)}++happyReduce_229 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_229 = happyMonadReduce 6# 88# happyReduction_229+happyReduction_229 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut160 happy_x_4 of { (HappyWrap160 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	case happyOut162 happy_x_6 of { (HappyWrap162 happy_var_6) -> +	( hintExplicitForall happy_var_1+                                                       >> (addAnnotation (gl happy_var_4) (toUnicodeAnn AnnDarrow happy_var_5) (gl happy_var_5)+                                                           >> return (sLL happy_var_1 happy_var_6 ([mu AnnForall happy_var_1, mj AnnDot happy_var_3]+                                                                                , (Just happy_var_4, Just happy_var_2, happy_var_6)))+                                                          ))}}}}}})+	) (\r -> happyReturn (happyIn104 r))++happyReduce_230 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_230 = happyMonadReduce 4# 88# happyReduction_230+happyReduction_230 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut162 happy_x_4 of { (HappyWrap162 happy_var_4) -> +	( hintExplicitForall happy_var_1+                                          >> return (sLL happy_var_1 happy_var_4 ([mu AnnForall happy_var_1, mj AnnDot happy_var_3]+                                                               , (Nothing, Just happy_var_2, happy_var_4))))}}}})+	) (\r -> happyReturn (happyIn104 r))++happyReduce_231 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_231 = happyMonadReduce 3# 88# happyReduction_231+happyReduction_231 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+                                       >> (return (sLL happy_var_1 happy_var_3([], (Just happy_var_1, Nothing, happy_var_3)))))}}})+	) (\r -> happyReturn (happyIn104 r))++happyReduce_232 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_232 = happySpecReduce_1  88# happyReduction_232+happyReduction_232 happy_x_1+	 =  case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> +	happyIn104+		 (sL1 happy_var_1 ([], (Nothing, Nothing, happy_var_1))+	)}++happyReduce_233 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_233 = happyMonadReduce 4# 89# happyReduction_233+happyReduction_233 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( ajs (sLL happy_var_1 happy_var_4 (CType (getCTYPEs happy_var_1) (Just (Header (getSTRINGs happy_var_2) (getSTRING happy_var_2)))+                                        (getSTRINGs happy_var_3,getSTRING happy_var_3)))+                              [mo happy_var_1,mj AnnHeader happy_var_2,mj AnnVal happy_var_3,mc happy_var_4])}}}})+	) (\r -> happyReturn (happyIn105 r))++happyReduce_234 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_234 = happyMonadReduce 3# 89# happyReduction_234+happyReduction_234 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ajs (sLL happy_var_1 happy_var_3 (CType (getCTYPEs happy_var_1) Nothing (getSTRINGs happy_var_2, getSTRING happy_var_2)))+                              [mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn105 r))++happyReduce_235 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_235 = happySpecReduce_0  89# happyReduction_235+happyReduction_235  =  happyIn105+		 (Nothing+	)++happyReduce_236 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_236 = happyMonadReduce 5# 90# happyReduction_236+happyReduction_236 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut86 happy_x_2 of { (HappyWrap86 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut83 happy_x_4 of { (HappyWrap83 happy_var_4) -> +	case happyOut171 happy_x_5 of { (HappyWrap171 happy_var_5) -> +	( do { let { err = text "in the stand-alone deriving instance"+                                    <> colon <+> quotes (ppr happy_var_5) }+                      ; ams (sLL happy_var_1 (hsSigType happy_var_5)+                                 (DerivDecl noExtField (mkHsWildCardBndrs happy_var_5) happy_var_2 happy_var_4))+                            [mj AnnDeriving happy_var_1, mj AnnInstance happy_var_3] })}}}}})+	) (\r -> happyReturn (happyIn106 r))++happyReduce_237 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_237 = happyMonadReduce 4# 91# happyReduction_237+happyReduction_237 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut283 happy_x_3 of { (HappyWrap283 happy_var_3) -> +	case happyOut108 happy_x_4 of { (HappyWrap108 happy_var_4) -> +	( amms (mkRoleAnnotDecl (comb3 happy_var_1 happy_var_3 happy_var_4) happy_var_3 (reverse (unLoc happy_var_4)))+                  [mj AnnType happy_var_1,mj AnnRole happy_var_2])}}}})+	) (\r -> happyReturn (happyIn107 r))++happyReduce_238 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_238 = happySpecReduce_0  92# happyReduction_238+happyReduction_238  =  happyIn108+		 (noLoc []+	)++happyReduce_239 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_239 = happySpecReduce_1  92# happyReduction_239+happyReduction_239 happy_x_1+	 =  case happyOut109 happy_x_1 of { (HappyWrap109 happy_var_1) -> +	happyIn108+		 (happy_var_1+	)}++happyReduce_240 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_240 = happySpecReduce_1  93# happyReduction_240+happyReduction_240 happy_x_1+	 =  case happyOut110 happy_x_1 of { (HappyWrap110 happy_var_1) -> +	happyIn109+		 (sLL happy_var_1 happy_var_1 [happy_var_1]+	)}++happyReduce_241 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_241 = happySpecReduce_2  93# happyReduction_241+happyReduction_241 happy_x_2+	happy_x_1+	 =  case happyOut109 happy_x_1 of { (HappyWrap109 happy_var_1) -> +	case happyOut110 happy_x_2 of { (HappyWrap110 happy_var_2) -> +	happyIn109+		 (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1+	)}}++happyReduce_242 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_242 = happySpecReduce_1  94# happyReduction_242+happyReduction_242 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn110+		 (sL1 happy_var_1 $ Just $ getVARID happy_var_1+	)}++happyReduce_243 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_243 = happySpecReduce_1  94# happyReduction_243+happyReduction_243 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn110+		 (sL1 happy_var_1 Nothing+	)}++happyReduce_244 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_244 = happyMonadReduce 4# 95# happyReduction_244+happyReduction_244 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut112 happy_x_2 of { (HappyWrap112 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut248 happy_x_4 of { (HappyWrap248 happy_var_4) -> +	(      let (name, args,as ) = happy_var_2 in+                 ams (sLL happy_var_1 happy_var_4 . ValD noExtField $ mkPatSynBind name args happy_var_4+                                                    ImplicitBidirectional)+               (as ++ [mj AnnPattern happy_var_1, mj AnnEqual happy_var_3]))}}}})+	) (\r -> happyReturn (happyIn111 r))++happyReduce_245 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_245 = happyMonadReduce 4# 95# happyReduction_245+happyReduction_245 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut112 happy_x_2 of { (HappyWrap112 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut248 happy_x_4 of { (HappyWrap248 happy_var_4) -> +	(    let (name, args, as) = happy_var_2 in+               ams (sLL happy_var_1 happy_var_4 . ValD noExtField $ mkPatSynBind name args happy_var_4 Unidirectional)+               (as ++ [mj AnnPattern happy_var_1,mu AnnLarrow happy_var_3]))}}}})+	) (\r -> happyReturn (happyIn111 r))++happyReduce_246 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_246 = happyMonadReduce 5# 95# happyReduction_246+happyReduction_246 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut112 happy_x_2 of { (HappyWrap112 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut248 happy_x_4 of { (HappyWrap248 happy_var_4) -> +	case happyOut115 happy_x_5 of { (HappyWrap115 happy_var_5) -> +	( do { let (name, args, as) = happy_var_2+                  ; mg <- mkPatSynMatchGroup name (snd $ unLoc happy_var_5)+                  ; ams (sLL happy_var_1 happy_var_5 . ValD noExtField $+                           mkPatSynBind name args happy_var_4 (ExplicitBidirectional mg))+                       (as ++ ((mj AnnPattern happy_var_1:mu AnnLarrow happy_var_3:(fst $ unLoc happy_var_5))) )+                   })}}}}})+	) (\r -> happyReturn (happyIn111 r))++happyReduce_247 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_247 = happySpecReduce_2  96# happyReduction_247+happyReduction_247 happy_x_2+	happy_x_1+	 =  case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> +	case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> +	happyIn112+		 ((happy_var_1, PrefixCon happy_var_2, [])+	)}}++happyReduce_248 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_248 = happySpecReduce_3  96# happyReduction_248+happyReduction_248 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> +	case happyOut279 happy_x_2 of { (HappyWrap279 happy_var_2) -> +	case happyOut304 happy_x_3 of { (HappyWrap304 happy_var_3) -> +	happyIn112+		 ((happy_var_2, InfixCon happy_var_1 happy_var_3, [])+	)}}}++happyReduce_249 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_249 = happyReduce 4# 96# happyReduction_249+happyReduction_249 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut114 happy_x_3 of { (HappyWrap114 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn112+		 ((happy_var_1, RecCon happy_var_3, [moc happy_var_2, mcc happy_var_4] )+	) `HappyStk` happyRest}}}}++happyReduce_250 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_250 = happySpecReduce_0  97# happyReduction_250+happyReduction_250  =  happyIn113+		 ([]+	)++happyReduce_251 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_251 = happySpecReduce_2  97# happyReduction_251+happyReduction_251 happy_x_2+	happy_x_1+	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> +	case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> +	happyIn113+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_252 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_252 = happySpecReduce_1  98# happyReduction_252+happyReduction_252 happy_x_1+	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> +	happyIn114+		 ([RecordPatSynField happy_var_1 happy_var_1]+	)}++happyReduce_253 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_253 = happyMonadReduce 3# 98# happyReduction_253+happyReduction_253 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut114 happy_x_3 of { (HappyWrap114 happy_var_3) -> +	( addAnnotation (getLoc happy_var_1) AnnComma (getLoc happy_var_2) >>+                                         return ((RecordPatSynField happy_var_1 happy_var_1) : happy_var_3 ))}}})+	) (\r -> happyReturn (happyIn114 r))++happyReduce_254 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_254 = happyReduce 4# 99# happyReduction_254+happyReduction_254 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut125 happy_x_3 of { (HappyWrap125 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn115+		 (sLL happy_var_1 happy_var_4 ((mj AnnWhere happy_var_1:moc happy_var_2+                                           :mcc happy_var_4:(fst $ unLoc happy_var_3)),sL1 happy_var_3 (snd $ unLoc happy_var_3))+	) `HappyStk` happyRest}}}}++happyReduce_255 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_255 = happyReduce 4# 99# happyReduction_255+happyReduction_255 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut125 happy_x_3 of { (HappyWrap125 happy_var_3) -> +	happyIn115+		 (L (comb2 happy_var_1 happy_var_3) ((mj AnnWhere happy_var_1:(fst $ unLoc happy_var_3))+                                          ,sL1 happy_var_3 (snd $ unLoc happy_var_3))+	) `HappyStk` happyRest}}++happyReduce_256 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_256 = happyMonadReduce 4# 100# happyReduction_256+happyReduction_256 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut276 happy_x_2 of { (HappyWrap276 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut151 happy_x_4 of { (HappyWrap151 happy_var_4) -> +	( ams (sLL happy_var_1 happy_var_4 $ PatSynSig noExtField (unLoc happy_var_2) (mkLHsSigType happy_var_4))+                          [mj AnnPattern happy_var_1, mu AnnDcolon happy_var_3])}}}})+	) (\r -> happyReturn (happyIn116 r))++happyReduce_257 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_257 = happySpecReduce_1  101# happyReduction_257+happyReduction_257 happy_x_1+	 =  case happyOut94 happy_x_1 of { (HappyWrap94 happy_var_1) -> +	happyIn117+		 (happy_var_1+	)}++happyReduce_258 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_258 = happySpecReduce_1  101# happyReduction_258+happyReduction_258 happy_x_1+	 =  case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> +	happyIn117+		 (happy_var_1+	)}++happyReduce_259 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_259 = happyMonadReduce 4# 101# happyReduction_259+happyReduction_259 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut211 happy_x_2 of { (HappyWrap211 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut151 happy_x_4 of { (HappyWrap151 happy_var_4) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                       do { v <- checkValSigLhs happy_var_2+                          ; let err = text "in default signature" <> colon <+>+                                      quotes (ppr happy_var_2)+                          ; ams (sLL happy_var_1 happy_var_4 $ SigD noExtField $ ClassOpSig noExtField True [v] $ mkLHsSigType happy_var_4)+                                [mj AnnDefault happy_var_1,mu AnnDcolon happy_var_3] })}}}})+	) (\r -> happyReturn (happyIn117 r))++happyReduce_260 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_260 = happyMonadReduce 3# 102# happyReduction_260+happyReduction_260 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut118 happy_x_1 of { (HappyWrap118 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut117 happy_x_3 of { (HappyWrap117 happy_var_3) -> +	( if isNilOL (snd $ unLoc happy_var_1)+                                             then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                                    , unitOL happy_var_3))+                                             else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]+                                           >> return (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1+                                                                ,(snd $ unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})+	) (\r -> happyReturn (happyIn118 r))++happyReduce_261 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_261 = happyMonadReduce 2# 102# happyReduction_261+happyReduction_261 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut118 happy_x_1 of { (HappyWrap118 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( if isNilOL (snd $ unLoc happy_var_1)+                                             then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                                                   ,snd $ unLoc happy_var_1))+                                             else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]+                                           >> return (sLL happy_var_1 happy_var_2  (unLoc happy_var_1)))}})+	) (\r -> happyReturn (happyIn118 r))++happyReduce_262 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_262 = happySpecReduce_1  102# happyReduction_262+happyReduction_262 happy_x_1+	 =  case happyOut117 happy_x_1 of { (HappyWrap117 happy_var_1) -> +	happyIn118+		 (sL1 happy_var_1 ([], unitOL happy_var_1)+	)}++happyReduce_263 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_263 = happySpecReduce_0  102# happyReduction_263+happyReduction_263  =  happyIn118+		 (noLoc ([],nilOL)+	)++happyReduce_264 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_264 = happySpecReduce_3  103# happyReduction_264+happyReduction_264 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut118 happy_x_2 of { (HappyWrap118 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn119+		 (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)+                                             ,snd $ unLoc happy_var_2)+	)}}}++happyReduce_265 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_265 = happySpecReduce_3  103# happyReduction_265+happyReduction_265 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut118 happy_x_2 of { (HappyWrap118 happy_var_2) -> +	happyIn119+		 (happy_var_2+	)}++happyReduce_266 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_266 = happySpecReduce_2  104# happyReduction_266+happyReduction_266 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut119 happy_x_2 of { (HappyWrap119 happy_var_2) -> +	happyIn120+		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)+                                             ,snd $ unLoc happy_var_2)+	)}}++happyReduce_267 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_267 = happySpecReduce_0  104# happyReduction_267+happyReduction_267  =  happyIn120+		 (noLoc ([],nilOL)+	)++happyReduce_268 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_268 = happySpecReduce_1  105# happyReduction_268+happyReduction_268 happy_x_1+	 =  case happyOut97 happy_x_1 of { (HappyWrap97 happy_var_1) -> +	happyIn121+		 (sLL happy_var_1 happy_var_1 (unitOL (sL1 happy_var_1 (InstD noExtField (unLoc happy_var_1))))+	)}++happyReduce_269 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_269 = happySpecReduce_1  105# happyReduction_269+happyReduction_269 happy_x_1+	 =  case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> +	happyIn121+		 (sLL happy_var_1 happy_var_1 (unitOL happy_var_1)+	)}++happyReduce_270 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_270 = happyMonadReduce 3# 106# happyReduction_270+happyReduction_270 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut122 happy_x_1 of { (HappyWrap122 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut121 happy_x_3 of { (HappyWrap121 happy_var_3) -> +	( if isNilOL (snd $ unLoc happy_var_1)+                                             then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                                    , unLoc happy_var_3))+                                             else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+                                           >> return+                                            (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1+                                                       ,(snd $ unLoc happy_var_1) `appOL` unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn122 r))++happyReduce_271 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_271 = happyMonadReduce 2# 106# happyReduction_271+happyReduction_271 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut122 happy_x_1 of { (HappyWrap122 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( if isNilOL (snd $ unLoc happy_var_1)+                                             then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                                                   ,snd $ unLoc happy_var_1))+                                             else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+                                           >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+	) (\r -> happyReturn (happyIn122 r))++happyReduce_272 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_272 = happySpecReduce_1  106# happyReduction_272+happyReduction_272 happy_x_1+	 =  case happyOut121 happy_x_1 of { (HappyWrap121 happy_var_1) -> +	happyIn122+		 (sL1 happy_var_1 ([],unLoc happy_var_1)+	)}++happyReduce_273 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_273 = happySpecReduce_0  106# happyReduction_273+happyReduction_273  =  happyIn122+		 (noLoc ([],nilOL)+	)++happyReduce_274 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_274 = happySpecReduce_3  107# happyReduction_274+happyReduction_274 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut122 happy_x_2 of { (HappyWrap122 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn123+		 (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2),snd $ unLoc happy_var_2)+	)}}}++happyReduce_275 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_275 = happySpecReduce_3  107# happyReduction_275+happyReduction_275 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut122 happy_x_2 of { (HappyWrap122 happy_var_2) -> +	happyIn123+		 (L (gl happy_var_2) (unLoc happy_var_2)+	)}++happyReduce_276 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_276 = happySpecReduce_2  108# happyReduction_276+happyReduction_276 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut123 happy_x_2 of { (HappyWrap123 happy_var_2) -> +	happyIn124+		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)+                                             ,(snd $ unLoc happy_var_2))+	)}}++happyReduce_277 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_277 = happySpecReduce_0  108# happyReduction_277+happyReduction_277  =  happyIn124+		 (noLoc ([],nilOL)+	)++happyReduce_278 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_278 = happyMonadReduce 3# 109# happyReduction_278+happyReduction_278 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut125 happy_x_1 of { (HappyWrap125 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut202 happy_x_3 of { (HappyWrap202 happy_var_3) -> +	( if isNilOL (snd $ unLoc happy_var_1)+                                 then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                        , unitOL happy_var_3))+                                 else do ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+                                           >> return (+                                          let { this = unitOL happy_var_3;+                                                rest = snd $ unLoc happy_var_1;+                                                these = rest `appOL` this }+                                          in rest `seq` this `seq` these `seq`+                                             (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,these))))}}})+	) (\r -> happyReturn (happyIn125 r))++happyReduce_279 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_279 = happyMonadReduce 2# 109# happyReduction_279+happyReduction_279 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut125 happy_x_1 of { (HappyWrap125 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( if isNilOL (snd $ unLoc happy_var_1)+                                  then return (sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                          ,snd $ unLoc happy_var_1)))+                                  else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+                                           >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+	) (\r -> happyReturn (happyIn125 r))++happyReduce_280 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_280 = happySpecReduce_1  109# happyReduction_280+happyReduction_280 happy_x_1+	 =  case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> +	happyIn125+		 (sL1 happy_var_1 ([], unitOL happy_var_1)+	)}++happyReduce_281 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_281 = happySpecReduce_0  109# happyReduction_281+happyReduction_281  =  happyIn125+		 (noLoc ([],nilOL)+	)++happyReduce_282 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_282 = happySpecReduce_3  110# happyReduction_282+happyReduction_282 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut125 happy_x_2 of { (HappyWrap125 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn126+		 (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)+                                                   ,sL1 happy_var_2 $ snd $ unLoc happy_var_2)+	)}}}++happyReduce_283 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_283 = happySpecReduce_3  110# happyReduction_283+happyReduction_283 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut125 happy_x_2 of { (HappyWrap125 happy_var_2) -> +	happyIn126+		 (L (gl happy_var_2) (fst $ unLoc happy_var_2,sL1 happy_var_2 $ snd $ unLoc happy_var_2)+	)}++happyReduce_284 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_284 = happyMonadReduce 1# 111# happyReduction_284+happyReduction_284 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut126 happy_x_1 of { (HappyWrap126 happy_var_1) -> +	( do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc happy_var_1)+                                  ; return (sL1 happy_var_1 (fst $ unLoc happy_var_1+                                                    ,sL1 happy_var_1 $ HsValBinds noExtField val_binds)) })})+	) (\r -> happyReturn (happyIn127 r))++happyReduce_285 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_285 = happySpecReduce_3  111# happyReduction_285+happyReduction_285 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut261 happy_x_2 of { (HappyWrap261 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn127+		 (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]+                                             ,sL1 happy_var_2 $ HsIPBinds noExtField (IPBinds noExtField (reverse $ unLoc happy_var_2)))+	)}}}++happyReduce_286 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_286 = happySpecReduce_3  111# happyReduction_286+happyReduction_286 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut261 happy_x_2 of { (HappyWrap261 happy_var_2) -> +	happyIn127+		 (L (getLoc happy_var_2) ([]+                                            ,sL1 happy_var_2 $ HsIPBinds noExtField (IPBinds noExtField (reverse $ unLoc happy_var_2)))+	)}++happyReduce_287 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_287 = happySpecReduce_2  112# happyReduction_287+happyReduction_287 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> +	happyIn128+		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1 : (fst $ unLoc happy_var_2)+                                             ,snd $ unLoc happy_var_2)+	)}}++happyReduce_288 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_288 = happySpecReduce_0  112# happyReduction_288+happyReduction_288  =  happyIn128+		 (noLoc ([],noLoc emptyLocalBinds)+	)++happyReduce_289 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_289 = happyMonadReduce 3# 113# happyReduction_289+happyReduction_289 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut129 happy_x_1 of { (HappyWrap129 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut130 happy_x_3 of { (HappyWrap130 happy_var_3) -> +	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+                                          >> return (happy_var_1 `snocOL` happy_var_3))}}})+	) (\r -> happyReturn (happyIn129 r))++happyReduce_290 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_290 = happyMonadReduce 2# 113# happyReduction_290+happyReduction_290 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut129 happy_x_1 of { (HappyWrap129 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+                                          >> return happy_var_1)}})+	) (\r -> happyReturn (happyIn129 r))++happyReduce_291 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_291 = happySpecReduce_1  113# happyReduction_291+happyReduction_291 happy_x_1+	 =  case happyOut130 happy_x_1 of { (HappyWrap130 happy_var_1) -> +	happyIn129+		 (unitOL happy_var_1+	)}++happyReduce_292 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_292 = happySpecReduce_0  113# happyReduction_292+happyReduction_292  =  happyIn129+		 (nilOL+	)++happyReduce_293 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_293 = happyMonadReduce 6# 114# happyReduction_293+happyReduction_293 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut131 happy_x_2 of { (HappyWrap131 happy_var_2) -> +	case happyOut134 happy_x_3 of { (HappyWrap134 happy_var_3) -> +	case happyOut211 happy_x_4 of { (HappyWrap211 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	case happyOut210 happy_x_6 of { (HappyWrap210 happy_var_6) -> +	(runECP_P happy_var_4 >>= \ happy_var_4 ->+           runECP_P happy_var_6 >>= \ happy_var_6 ->+           ams (sLL happy_var_1 happy_var_6 $ HsRule { rd_ext = noExtField+                                   , rd_name = L (gl happy_var_1) (getSTRINGs happy_var_1, getSTRING happy_var_1)+                                   , rd_act = (snd happy_var_2) `orElse` AlwaysActive+                                   , rd_tyvs = sndOf3 happy_var_3, rd_tmvs = thdOf3 happy_var_3+                                   , rd_lhs = happy_var_4, rd_rhs = happy_var_6 })+               (mj AnnEqual happy_var_5 : (fst happy_var_2) ++ (fstOf3 happy_var_3)))}}}}}})+	) (\r -> happyReturn (happyIn130 r))++happyReduce_294 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_294 = happySpecReduce_0  115# happyReduction_294+happyReduction_294  =  happyIn131+		 (([],Nothing)+	)++happyReduce_295 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_295 = happySpecReduce_1  115# happyReduction_295+happyReduction_295 happy_x_1+	 =  case happyOut133 happy_x_1 of { (HappyWrap133 happy_var_1) -> +	happyIn131+		 ((fst happy_var_1,Just (snd happy_var_1))+	)}++happyReduce_296 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_296 = happySpecReduce_1  116# happyReduction_296+happyReduction_296 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn132+		 ([mj AnnTilde happy_var_1]+	)}++happyReduce_297 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_297 = happyMonadReduce 1# 116# happyReduction_297+happyReduction_297 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( if (getVARSYM happy_var_1 == fsLit "~")+                   then return [mj AnnTilde happy_var_1]+                   else do { addError (getLoc happy_var_1) $ text "Invalid rule activation marker"+                           ; return [] })})+	) (\r -> happyReturn (happyIn132 r))++happyReduce_298 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_298 = happySpecReduce_3  117# happyReduction_298+happyReduction_298 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn133+		 (([mos happy_var_1,mj AnnVal happy_var_2,mcs happy_var_3]+                                  ,ActiveAfter  (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))+	)}}}++happyReduce_299 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_299 = happyReduce 4# 117# happyReduction_299+happyReduction_299 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn133+		 ((happy_var_2++[mos happy_var_1,mj AnnVal happy_var_3,mcs happy_var_4]+                                  ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))+	) `HappyStk` happyRest}}}}++happyReduce_300 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_300 = happySpecReduce_3  117# happyReduction_300+happyReduction_300 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn133+		 ((happy_var_2++[mos happy_var_1,mcs happy_var_3]+                                  ,NeverActive)+	)}}}++happyReduce_301 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_301 = happyMonadReduce 6# 118# happyReduction_301+happyReduction_301 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut135 happy_x_5 of { (HappyWrap135 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	( let tyvs = mkRuleTyVarBndrs happy_var_2+                                                              in hintExplicitForall happy_var_1+                                                              >> checkRuleTyVarBndrNames (mkRuleTyVarBndrs happy_var_2)+                                                              >> return ([mu AnnForall happy_var_1,mj AnnDot happy_var_3,+                                                                          mu AnnForall happy_var_4,mj AnnDot happy_var_6],+                                                                         Just (mkRuleTyVarBndrs happy_var_2), mkRuleBndrs happy_var_5))}}}}}})+	) (\r -> happyReturn (happyIn134 r))++happyReduce_302 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_302 = happySpecReduce_3  118# happyReduction_302+happyReduction_302 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn134+		 (([mu AnnForall happy_var_1,mj AnnDot happy_var_3],+                                                              Nothing, mkRuleBndrs happy_var_2)+	)}}}++happyReduce_303 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_303 = happySpecReduce_0  118# happyReduction_303+happyReduction_303  =  happyIn134+		 (([], Nothing, [])+	)++happyReduce_304 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_304 = happySpecReduce_2  119# happyReduction_304+happyReduction_304 happy_x_2+	happy_x_1+	 =  case happyOut136 happy_x_1 of { (HappyWrap136 happy_var_1) -> +	case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> +	happyIn135+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_305 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_305 = happySpecReduce_0  119# happyReduction_305+happyReduction_305  =  happyIn135+		 ([]+	)++happyReduce_306 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_306 = happySpecReduce_1  120# happyReduction_306+happyReduction_306 happy_x_1+	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> +	happyIn136+		 (sLL happy_var_1 happy_var_1 (RuleTyTmVar happy_var_1 Nothing)+	)}++happyReduce_307 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_307 = happyMonadReduce 5# 120# happyReduction_307+happyReduction_307 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut304 happy_x_2 of { (HappyWrap304 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	( ams (sLL happy_var_1 happy_var_5 (RuleTyTmVar happy_var_2 (Just happy_var_4)))+                                               [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5])}}}}})+	) (\r -> happyReturn (happyIn136 r))++happyReduce_308 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_308 = happyMonadReduce 3# 121# happyReduction_308+happyReduction_308 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut137 happy_x_1 of { (HappyWrap137 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut138 happy_x_3 of { (HappyWrap138 happy_var_3) -> +	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+                                          >> return (happy_var_1 `appOL` happy_var_3))}}})+	) (\r -> happyReturn (happyIn137 r))++happyReduce_309 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_309 = happyMonadReduce 2# 121# happyReduction_309+happyReduction_309 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut137 happy_x_1 of { (HappyWrap137 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+                                          >> return happy_var_1)}})+	) (\r -> happyReturn (happyIn137 r))++happyReduce_310 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_310 = happySpecReduce_1  121# happyReduction_310+happyReduction_310 happy_x_1+	 =  case happyOut138 happy_x_1 of { (HappyWrap138 happy_var_1) -> +	happyIn137+		 (happy_var_1+	)}++happyReduce_311 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_311 = happySpecReduce_0  121# happyReduction_311+happyReduction_311  =  happyIn137+		 (nilOL+	)++happyReduce_312 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_312 = happyMonadReduce 2# 122# happyReduction_312+happyReduction_312 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut270 happy_x_1 of { (HappyWrap270 happy_var_1) -> +	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> +	( amsu (sLL happy_var_1 happy_var_2 (Warning noExtField (unLoc happy_var_1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))+                     (fst $ unLoc happy_var_2))}})+	) (\r -> happyReturn (happyIn138 r))++happyReduce_313 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_313 = happyMonadReduce 3# 123# happyReduction_313+happyReduction_313 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut139 happy_x_1 of { (HappyWrap139 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut140 happy_x_3 of { (HappyWrap140 happy_var_3) -> +	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+                                          >> return (happy_var_1 `appOL` happy_var_3))}}})+	) (\r -> happyReturn (happyIn139 r))++happyReduce_314 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_314 = happyMonadReduce 2# 123# happyReduction_314+happyReduction_314 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut139 happy_x_1 of { (HappyWrap139 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)+                                          >> return happy_var_1)}})+	) (\r -> happyReturn (happyIn139 r))++happyReduce_315 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_315 = happySpecReduce_1  123# happyReduction_315+happyReduction_315 happy_x_1+	 =  case happyOut140 happy_x_1 of { (HappyWrap140 happy_var_1) -> +	happyIn139+		 (happy_var_1+	)}++happyReduce_316 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_316 = happySpecReduce_0  123# happyReduction_316+happyReduction_316  =  happyIn139+		 (nilOL+	)++happyReduce_317 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_317 = happyMonadReduce 2# 124# happyReduction_317+happyReduction_317 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut270 happy_x_1 of { (HappyWrap270 happy_var_1) -> +	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> +	( amsu (sLL happy_var_1 happy_var_2 $ (Warning noExtField (unLoc happy_var_1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))+                     (fst $ unLoc happy_var_2))}})+	) (\r -> happyReturn (happyIn140 r))++happyReduce_318 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_318 = happySpecReduce_1  125# happyReduction_318+happyReduction_318 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn141+		 (sL1 happy_var_1 ([],[L (gl happy_var_1) (getStringLiteral happy_var_1)])+	)}++happyReduce_319 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_319 = happySpecReduce_3  125# happyReduction_319+happyReduction_319 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut142 happy_x_2 of { (HappyWrap142 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn141+		 (sLL happy_var_1 happy_var_3 $ ([mos happy_var_1,mcs happy_var_3],fromOL (unLoc happy_var_2))+	)}}}++happyReduce_320 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_320 = happyMonadReduce 3# 126# happyReduction_320+happyReduction_320 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut142 happy_x_1 of { (HappyWrap142 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+                               return (sLL happy_var_1 happy_var_3 (unLoc happy_var_1 `snocOL`+                                                  (L (gl happy_var_3) (getStringLiteral happy_var_3)))))}}})+	) (\r -> happyReturn (happyIn142 r))++happyReduce_321 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_321 = happySpecReduce_1  126# happyReduction_321+happyReduction_321 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn142+		 (sLL happy_var_1 happy_var_1 (unitOL (L (gl happy_var_1) (getStringLiteral happy_var_1)))+	)}++happyReduce_322 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_322 = happySpecReduce_0  126# happyReduction_322+happyReduction_322  =  happyIn142+		 (noLoc nilOL+	)++happyReduce_323 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_323 = happyMonadReduce 4# 127# happyReduction_323+happyReduction_323 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut271 happy_x_2 of { (HappyWrap271 happy_var_2) -> +	case happyOut217 happy_x_3 of { (HappyWrap217 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( runECP_P happy_var_3 >>= \ happy_var_3 ->+                                            ams (sLL happy_var_1 happy_var_4 (AnnD noExtField $ HsAnnotation noExtField+                                            (getANN_PRAGs happy_var_1)+                                            (ValueAnnProvenance happy_var_2) happy_var_3))+                                            [mo happy_var_1,mc happy_var_4])}}}})+	) (\r -> happyReturn (happyIn143 r))++happyReduce_324 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_324 = happyMonadReduce 5# 127# happyReduction_324+happyReduction_324 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut288 happy_x_3 of { (HappyWrap288 happy_var_3) -> +	case happyOut217 happy_x_4 of { (HappyWrap217 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	( runECP_P happy_var_4 >>= \ happy_var_4 ->+                                            ams (sLL happy_var_1 happy_var_5 (AnnD noExtField $ HsAnnotation noExtField+                                            (getANN_PRAGs happy_var_1)+                                            (TypeAnnProvenance happy_var_3) happy_var_4))+                                            [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_5])}}}}})+	) (\r -> happyReturn (happyIn143 r))++happyReduce_325 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_325 = happyMonadReduce 4# 127# happyReduction_325+happyReduction_325 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut217 happy_x_3 of { (HappyWrap217 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( runECP_P happy_var_3 >>= \ happy_var_3 ->+                                            ams (sLL happy_var_1 happy_var_4 (AnnD noExtField $ HsAnnotation noExtField+                                                (getANN_PRAGs happy_var_1)+                                                 ModuleAnnProvenance happy_var_3))+                                                [mo happy_var_1,mj AnnModule happy_var_2,mc happy_var_4])}}}})+	) (\r -> happyReturn (happyIn143 r))++happyReduce_326 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_326 = happyMonadReduce 4# 128# happyReduction_326+happyReduction_326 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut145 happy_x_2 of { (HappyWrap145 happy_var_2) -> +	case happyOut146 happy_x_3 of { (HappyWrap146 happy_var_3) -> +	case happyOut147 happy_x_4 of { (HappyWrap147 happy_var_4) -> +	( mkImport happy_var_2 happy_var_3 (snd $ unLoc happy_var_4) >>= \i ->+                 return (sLL happy_var_1 happy_var_4 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_4),i)))}}}})+	) (\r -> happyReturn (happyIn144 r))++happyReduce_327 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_327 = happyMonadReduce 3# 128# happyReduction_327+happyReduction_327 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut145 happy_x_2 of { (HappyWrap145 happy_var_2) -> +	case happyOut147 happy_x_3 of { (HappyWrap147 happy_var_3) -> +	( do { d <- mkImport happy_var_2 (noLoc PlaySafe) (snd $ unLoc happy_var_3);+                    return (sLL happy_var_1 happy_var_3 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_3),d)) })}}})+	) (\r -> happyReturn (happyIn144 r))++happyReduce_328 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_328 = happyMonadReduce 3# 128# happyReduction_328+happyReduction_328 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut145 happy_x_2 of { (HappyWrap145 happy_var_2) -> +	case happyOut147 happy_x_3 of { (HappyWrap147 happy_var_3) -> +	( mkExport happy_var_2 (snd $ unLoc happy_var_3) >>= \i ->+                  return (sLL happy_var_1 happy_var_3 (mj AnnExport happy_var_1 : (fst $ unLoc happy_var_3),i) ))}}})+	) (\r -> happyReturn (happyIn144 r))++happyReduce_329 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_329 = happySpecReduce_1  129# happyReduction_329+happyReduction_329 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn145+		 (sLL happy_var_1 happy_var_1 StdCallConv+	)}++happyReduce_330 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_330 = happySpecReduce_1  129# happyReduction_330+happyReduction_330 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn145+		 (sLL happy_var_1 happy_var_1 CCallConv+	)}++happyReduce_331 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_331 = happySpecReduce_1  129# happyReduction_331+happyReduction_331 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn145+		 (sLL happy_var_1 happy_var_1 CApiConv+	)}++happyReduce_332 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_332 = happySpecReduce_1  129# happyReduction_332+happyReduction_332 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn145+		 (sLL happy_var_1 happy_var_1 PrimCallConv+	)}++happyReduce_333 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_333 = happySpecReduce_1  129# happyReduction_333+happyReduction_333 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn145+		 (sLL happy_var_1 happy_var_1 JavaScriptCallConv+	)}++happyReduce_334 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_334 = happySpecReduce_1  130# happyReduction_334+happyReduction_334 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn146+		 (sLL happy_var_1 happy_var_1 PlayRisky+	)}++happyReduce_335 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_335 = happySpecReduce_1  130# happyReduction_335+happyReduction_335 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn146+		 (sLL happy_var_1 happy_var_1 PlaySafe+	)}++happyReduce_336 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_336 = happySpecReduce_1  130# happyReduction_336+happyReduction_336 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn146+		 (sLL happy_var_1 happy_var_1 PlayInterruptible+	)}++happyReduce_337 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_337 = happyReduce 4# 131# happyReduction_337+happyReduction_337 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut301 happy_x_2 of { (HappyWrap301 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut151 happy_x_4 of { (HappyWrap151 happy_var_4) -> +	happyIn147+		 (sLL happy_var_1 happy_var_4 ([mu AnnDcolon happy_var_3]+                                             ,(L (getLoc happy_var_1)+                                                    (getStringLiteral happy_var_1), happy_var_2, mkLHsSigType happy_var_4))+	) `HappyStk` happyRest}}}}++happyReduce_338 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_338 = happySpecReduce_3  131# happyReduction_338+happyReduction_338 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> +	happyIn147+		 (sLL happy_var_1 happy_var_3 ([mu AnnDcolon happy_var_2]+                                             ,(noLoc (StringLiteral NoSourceText nilFS), happy_var_1, mkLHsSigType happy_var_3))+	)}}}++happyReduce_339 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_339 = happySpecReduce_0  132# happyReduction_339+happyReduction_339  =  happyIn148+		 (([],Nothing)+	)++happyReduce_340 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_340 = happySpecReduce_2  132# happyReduction_340+happyReduction_340 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut150 happy_x_2 of { (HappyWrap150 happy_var_2) -> +	happyIn148+		 (([mu AnnDcolon happy_var_1],Just happy_var_2)+	)}}++happyReduce_341 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_341 = happySpecReduce_0  133# happyReduction_341+happyReduction_341  =  happyIn149+		 (([], Nothing)+	)++happyReduce_342 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_342 = happySpecReduce_2  133# happyReduction_342+happyReduction_342 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut281 happy_x_2 of { (HappyWrap281 happy_var_2) -> +	happyIn149+		 (([mu AnnDcolon happy_var_1], Just happy_var_2)+	)}}++happyReduce_343 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_343 = happySpecReduce_1  134# happyReduction_343+happyReduction_343 happy_x_1+	 =  case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> +	happyIn150+		 (happy_var_1+	)}++happyReduce_344 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_344 = happySpecReduce_1  135# happyReduction_344+happyReduction_344 happy_x_1+	 =  case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> +	happyIn151+		 (happy_var_1+	)}++happyReduce_345 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_345 = happyMonadReduce 3# 136# happyReduction_345+happyReduction_345 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut152 happy_x_1 of { (HappyWrap152 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut301 happy_x_3 of { (HappyWrap301 happy_var_3) -> +	( addAnnotation (gl $ head $ unLoc happy_var_1)+                                                       AnnComma (gl happy_var_2)+                                         >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+	) (\r -> happyReturn (happyIn152 r))++happyReduce_346 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_346 = happySpecReduce_1  136# happyReduction_346+happyReduction_346 happy_x_1+	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> +	happyIn152+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_347 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_347 = happySpecReduce_1  137# happyReduction_347+happyReduction_347 happy_x_1+	 =  case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> +	happyIn153+		 (unitOL (mkLHsSigType happy_var_1)+	)}++happyReduce_348 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_348 = happyMonadReduce 3# 137# happyReduction_348+happyReduction_348 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut153 happy_x_3 of { (HappyWrap153 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+                                >> return (unitOL (mkLHsSigType happy_var_1) `appOL` happy_var_3))}}})+	) (\r -> happyReturn (happyIn153 r))++happyReduce_349 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_349 = happySpecReduce_2  138# happyReduction_349+happyReduction_349 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn154+		 (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getUNPACK_PRAGs happy_var_1, SrcUnpack)+	)}}++happyReduce_350 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_350 = happySpecReduce_2  138# happyReduction_350+happyReduction_350 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn154+		 (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getNOUNPACK_PRAGs happy_var_1, SrcNoUnpack)+	)}}++happyReduce_351 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_351 = happySpecReduce_1  139# happyReduction_351+happyReduction_351 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn155+		 ((mj AnnDot happy_var_1,    ForallInvis)+	)}++happyReduce_352 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_352 = happySpecReduce_1  139# happyReduction_352+happyReduction_352 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn155+		 ((mu AnnRarrow happy_var_1, ForallVis)+	)}++happyReduce_353 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_353 = happySpecReduce_1  140# happyReduction_353+happyReduction_353 happy_x_1+	 =  case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> +	happyIn156+		 (happy_var_1+	)}++happyReduce_354 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_354 = happyMonadReduce 3# 140# happyReduction_354+happyReduction_354 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut182 happy_x_3 of { (HappyWrap182 happy_var_3) -> +	( ams (sLL happy_var_1 happy_var_3 $ HsKindSig noExtField happy_var_1 happy_var_3)+                                      [mu AnnDcolon happy_var_2])}}})+	) (\r -> happyReturn (happyIn156 r))++happyReduce_355 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_355 = happySpecReduce_1  141# happyReduction_355+happyReduction_355 happy_x_1+	 =  case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> +	happyIn157+		 (happy_var_1+	)}++happyReduce_356 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_356 = happyMonadReduce 3# 141# happyReduction_356+happyReduction_356 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut182 happy_x_3 of { (HappyWrap182 happy_var_3) -> +	( ams (sLL happy_var_1 happy_var_3 $ HsKindSig noExtField happy_var_1 happy_var_3)+                                      [mu AnnDcolon happy_var_2])}}})+	) (\r -> happyReturn (happyIn157 r))++happyReduce_357 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_357 = happyMonadReduce 4# 142# happyReduction_357+happyReduction_357 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	case happyOut155 happy_x_3 of { (HappyWrap155 happy_var_3) -> +	case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> +	( let (fv_ann, fv_flag) = happy_var_3 in+                                           hintExplicitForall happy_var_1 *>+                                           ams (sLL happy_var_1 happy_var_4 $+                                                HsForAllTy { hst_fvf = fv_flag+                                                           , hst_bndrs = happy_var_2+                                                           , hst_xforall = noExtField+                                                           , hst_body = happy_var_4 })+                                               [mu AnnForall happy_var_1,fv_ann])}}}})+	) (\r -> happyReturn (happyIn158 r))++happyReduce_358 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_358 = happyMonadReduce 3# 142# happyReduction_358+happyReduction_358 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> +	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+                                         >> return (sLL happy_var_1 happy_var_3 $+                                            HsQualTy { hst_ctxt = happy_var_1+                                                     , hst_xqual = noExtField+                                                     , hst_body = happy_var_3 }))}}})+	) (\r -> happyReturn (happyIn158 r))++happyReduce_359 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_359 = happyMonadReduce 3# 142# happyReduction_359+happyReduction_359 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	( ams (sLL happy_var_1 happy_var_3 (HsIParamTy noExtField happy_var_1 happy_var_3))+                                             [mu AnnDcolon happy_var_2])}}})+	) (\r -> happyReturn (happyIn158 r))++happyReduce_360 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_360 = happySpecReduce_1  142# happyReduction_360+happyReduction_360 happy_x_1+	 =  case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> +	happyIn158+		 (happy_var_1+	)}++happyReduce_361 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_361 = happyMonadReduce 4# 143# happyReduction_361+happyReduction_361 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	case happyOut155 happy_x_3 of { (HappyWrap155 happy_var_3) -> +	case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> +	( let (fv_ann, fv_flag) = happy_var_3 in+                                            hintExplicitForall happy_var_1 *>+                                            ams (sLL happy_var_1 happy_var_4 $+                                                 HsForAllTy { hst_fvf = fv_flag+                                                            , hst_bndrs = happy_var_2+                                                            , hst_xforall = noExtField+                                                            , hst_body = happy_var_4 })+                                                [mu AnnForall happy_var_1,fv_ann])}}}})+	) (\r -> happyReturn (happyIn159 r))++happyReduce_362 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_362 = happyMonadReduce 3# 143# happyReduction_362+happyReduction_362 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> +	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)+                                         >> return (sLL happy_var_1 happy_var_3 $+                                            HsQualTy { hst_ctxt = happy_var_1+                                                     , hst_xqual = noExtField+                                                     , hst_body = happy_var_3 }))}}})+	) (\r -> happyReturn (happyIn159 r))++happyReduce_363 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_363 = happyMonadReduce 3# 143# happyReduction_363+happyReduction_363 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> +	( ams (sLL happy_var_1 happy_var_3 (HsIParamTy noExtField happy_var_1 happy_var_3))+                                             [mu AnnDcolon happy_var_2])}}})+	) (\r -> happyReturn (happyIn159 r))++happyReduce_364 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_364 = happySpecReduce_1  143# happyReduction_364+happyReduction_364 happy_x_1+	 =  case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> +	happyIn159+		 (happy_var_1+	)}++happyReduce_365 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_365 = happyMonadReduce 1# 144# happyReduction_365+happyReduction_365 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	( do { (anns,ctx) <- checkContext happy_var_1+                                                ; if null (unLoc ctx)+                                                   then addAnnotation (gl happy_var_1) AnnUnit (gl happy_var_1)+                                                   else return ()+                                                ; ams ctx anns+                                                })})+	) (\r -> happyReturn (happyIn160 r))++happyReduce_366 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_366 = happyMonadReduce 1# 145# happyReduction_366+happyReduction_366 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut164 happy_x_1 of { (HappyWrap164 happy_var_1) -> +	( do { (anns,ctx) <- checkContext happy_var_1+                                                ; if null (unLoc ctx)+                                                   then addAnnotation (gl happy_var_1) AnnUnit (gl happy_var_1)+                                                   else return ()+                                                ; ams ctx anns+                                                })})+	) (\r -> happyReturn (happyIn161 r))++happyReduce_367 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_367 = happySpecReduce_1  146# happyReduction_367+happyReduction_367 happy_x_1+	 =  case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	happyIn162+		 (happy_var_1+	)}++happyReduce_368 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_368 = happyMonadReduce 3# 146# happyReduction_368+happyReduction_368 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> +	( ams happy_var_1 [mu AnnRarrow happy_var_2] -- See note [GADT decl discards annotations]+                                       >> ams (sLL happy_var_1 happy_var_3 $ HsFunTy noExtField happy_var_1 happy_var_3)+                                              [mu AnnRarrow happy_var_2])}}})+	) (\r -> happyReturn (happyIn162 r))++happyReduce_369 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_369 = happySpecReduce_1  147# happyReduction_369+happyReduction_369 happy_x_1+	 =  case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	happyIn163+		 (happy_var_1+	)}++happyReduce_370 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_370 = happySpecReduce_2  147# happyReduction_370+happyReduction_370 happy_x_2+	happy_x_1+	 =  case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	case happyOut323 happy_x_2 of { (HappyWrap323 happy_var_2) -> +	happyIn163+		 (sLL happy_var_1 happy_var_2 $ HsDocTy noExtField happy_var_1 happy_var_2+	)}}++happyReduce_371 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_371 = happySpecReduce_2  147# happyReduction_371+happyReduction_371 happy_x_2+	happy_x_1+	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> +	case happyOut167 happy_x_2 of { (HappyWrap167 happy_var_2) -> +	happyIn163+		 (sLL happy_var_1 happy_var_2 $ HsDocTy noExtField happy_var_2 happy_var_1+	)}}++happyReduce_372 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_372 = happyMonadReduce 3# 147# happyReduction_372+happyReduction_372 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> +	( ams happy_var_1 [mu AnnRarrow happy_var_2] -- See note [GADT decl discards annotations]+                                         >> ams (sLL happy_var_1 happy_var_3 $ HsFunTy noExtField happy_var_1 happy_var_3)+                                                [mu AnnRarrow happy_var_2])}}})+	) (\r -> happyReturn (happyIn163 r))++happyReduce_373 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_373 = happyMonadReduce 4# 147# happyReduction_373+happyReduction_373 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> +	case happyOut323 happy_x_2 of { (HappyWrap323 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> +	( ams happy_var_1 [mu AnnRarrow happy_var_3] -- See note [GADT decl discards annotations]+                                         >> ams (sLL happy_var_1 happy_var_4 $+                                                 HsFunTy noExtField (L (comb2 happy_var_1 happy_var_2)+                                                            (HsDocTy noExtField happy_var_1 happy_var_2))+                                                         happy_var_4)+                                                [mu AnnRarrow happy_var_3])}}}})+	) (\r -> happyReturn (happyIn163 r))++happyReduce_374 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_374 = happyMonadReduce 4# 147# happyReduction_374+happyReduction_374 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> +	case happyOut167 happy_x_2 of { (HappyWrap167 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> +	( ams happy_var_2 [mu AnnRarrow happy_var_3] -- See note [GADT decl discards annotations]+                                         >> ams (sLL happy_var_1 happy_var_4 $+                                                 HsFunTy noExtField (L (comb2 happy_var_1 happy_var_2)+                                                            (HsDocTy noExtField happy_var_2 happy_var_1))+                                                         happy_var_4)+                                                [mu AnnRarrow happy_var_3])}}}})+	) (\r -> happyReturn (happyIn163 r))++happyReduce_375 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_375 = happyMonadReduce 1# 148# happyReduction_375+happyReduction_375 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> +	( mergeOps (unLoc happy_var_1))})+	) (\r -> happyReturn (happyIn164 r))++happyReduce_376 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_376 = happySpecReduce_1  149# happyReduction_376+happyReduction_376 happy_x_1+	 =  case happyOut166 happy_x_1 of { (HappyWrap166 happy_var_1) -> +	happyIn165+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_377 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_377 = happySpecReduce_2  149# happyReduction_377+happyReduction_377 happy_x_2+	happy_x_1+	 =  case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> +	case happyOut166 happy_x_2 of { (HappyWrap166 happy_var_2) -> +	happyIn165+		 (sLL happy_var_1 happy_var_2 $ happy_var_2 : (unLoc happy_var_1)+	)}}++happyReduce_378 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_378 = happySpecReduce_1  150# happyReduction_378+happyReduction_378 happy_x_1+	 =  case happyOut169 happy_x_1 of { (HappyWrap169 happy_var_1) -> +	happyIn166+		 (happy_var_1+	)}++happyReduce_379 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_379 = happySpecReduce_1  150# happyReduction_379+happyReduction_379 happy_x_1+	 =  case happyOut323 happy_x_1 of { (HappyWrap323 happy_var_1) -> +	happyIn166+		 (sL1 happy_var_1 $ TyElDocPrev (unLoc happy_var_1)+	)}++happyReduce_380 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_380 = happyMonadReduce 1# 151# happyReduction_380+happyReduction_380 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> +	( mergeOps happy_var_1)})+	) (\r -> happyReturn (happyIn167 r))++happyReduce_381 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_381 = happySpecReduce_1  152# happyReduction_381+happyReduction_381 happy_x_1+	 =  case happyOut169 happy_x_1 of { (HappyWrap169 happy_var_1) -> +	happyIn168+		 ([happy_var_1]+	)}++happyReduce_382 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_382 = happySpecReduce_2  152# happyReduction_382+happyReduction_382 happy_x_2+	happy_x_1+	 =  case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> +	case happyOut169 happy_x_2 of { (HappyWrap169 happy_var_2) -> +	happyIn168+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_383 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_383 = happySpecReduce_1  153# happyReduction_383+happyReduction_383 happy_x_1+	 =  case happyOut170 happy_x_1 of { (HappyWrap170 happy_var_1) -> +	happyIn169+		 (sL1 happy_var_1 $ TyElOpd (unLoc happy_var_1)+	)}++happyReduce_384 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_384 = happySpecReduce_2  153# happyReduction_384+happyReduction_384 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> +	happyIn169+		 (sLL happy_var_1 happy_var_2 $ (TyElKindApp (comb2 happy_var_1 happy_var_2) happy_var_2)+	)}}++happyReduce_385 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_385 = happySpecReduce_1  153# happyReduction_385+happyReduction_385 happy_x_1+	 =  case happyOut285 happy_x_1 of { (HappyWrap285 happy_var_1) -> +	happyIn169+		 (sL1 happy_var_1 $ TyElOpr (unLoc happy_var_1)+	)}++happyReduce_386 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_386 = happySpecReduce_1  153# happyReduction_386+happyReduction_386 happy_x_1+	 =  case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> +	happyIn169+		 (sL1 happy_var_1 $ TyElOpr (unLoc happy_var_1)+	)}++happyReduce_387 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_387 = happyMonadReduce 2# 153# happyReduction_387+happyReduction_387 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut280 happy_x_2 of { (HappyWrap280 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 $ TyElOpr (unLoc happy_var_2))+                                               [mj AnnSimpleQuote happy_var_1,mj AnnVal happy_var_2])}})+	) (\r -> happyReturn (happyIn169 r))++happyReduce_388 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_388 = happyMonadReduce 2# 153# happyReduction_388+happyReduction_388 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut292 happy_x_2 of { (HappyWrap292 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 $ TyElOpr (unLoc happy_var_2))+                                               [mj AnnSimpleQuote happy_var_1,mj AnnVal happy_var_2])}})+	) (\r -> happyReturn (happyIn169 r))++happyReduce_389 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_389 = happySpecReduce_1  153# happyReduction_389+happyReduction_389 happy_x_1+	 =  case happyOut154 happy_x_1 of { (HappyWrap154 happy_var_1) -> +	happyIn169+		 (sL1 happy_var_1 $ TyElUnpackedness (unLoc happy_var_1)+	)}++happyReduce_390 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_390 = happySpecReduce_1  154# happyReduction_390+happyReduction_390 happy_x_1+	 =  case happyOut282 happy_x_1 of { (HappyWrap282 happy_var_1) -> +	happyIn170+		 (sL1 happy_var_1 (HsTyVar noExtField NotPromoted happy_var_1)+	)}++happyReduce_391 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_391 = happySpecReduce_1  154# happyReduction_391+happyReduction_391 happy_x_1+	 =  case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> +	happyIn170+		 (sL1 happy_var_1 (HsTyVar noExtField NotPromoted happy_var_1)+	)}++happyReduce_392 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_392 = happyMonadReduce 1# 154# happyReduction_392+happyReduction_392 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( do { warnStarIsType (getLoc happy_var_1)+                                               ; return $ sL1 happy_var_1 (HsStarTy noExtField (isUnicode happy_var_1)) })})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_393 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_393 = happyMonadReduce 2# 154# happyReduction_393+happyReduction_393 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 (mkBangTy SrcLazy happy_var_2)) [mj AnnTilde happy_var_1])}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_394 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_394 = happyMonadReduce 2# 154# happyReduction_394+happyReduction_394 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 (mkBangTy SrcStrict happy_var_2)) [mj AnnBang happy_var_1])}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_395 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_395 = happyMonadReduce 3# 154# happyReduction_395+happyReduction_395 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut192 happy_x_2 of { (HappyWrap192 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( amms (checkRecordSyntax+                                                    (sLL happy_var_1 happy_var_3 $ HsRecTy noExtField happy_var_2))+                                                        -- Constructor sigs only+                                                 [moc happy_var_1,mcc happy_var_3])}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_396 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_396 = happyMonadReduce 2# 154# happyReduction_396+happyReduction_396 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy noExtField+                                                    HsBoxedOrConstraintTuple [])+                                                [mop happy_var_1,mcp happy_var_2])}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_397 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_397 = happyMonadReduce 5# 154# happyReduction_397+happyReduction_397 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut174 happy_x_4 of { (HappyWrap174 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	( addAnnotation (gl happy_var_2) AnnComma+                                                          (gl happy_var_3) >>+                                            ams (sLL happy_var_1 happy_var_5 $ HsTupleTy noExtField++                                             HsBoxedOrConstraintTuple (happy_var_2 : happy_var_4))+                                                [mop happy_var_1,mcp happy_var_5])}}}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_398 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_398 = happyMonadReduce 2# 154# happyReduction_398+happyReduction_398 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy noExtField HsUnboxedTuple [])+                                             [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_399 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_399 = happyMonadReduce 3# 154# happyReduction_399+happyReduction_399 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ HsTupleTy noExtField HsUnboxedTuple happy_var_2)+                                             [mo happy_var_1,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_400 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_400 = happyMonadReduce 3# 154# happyReduction_400+happyReduction_400 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut175 happy_x_2 of { (HappyWrap175 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ HsSumTy noExtField happy_var_2)+                                             [mo happy_var_1,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_401 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_401 = happyMonadReduce 3# 154# happyReduction_401+happyReduction_401 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ HsListTy  noExtField happy_var_2) [mos happy_var_1,mcs happy_var_3])}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_402 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_402 = happyMonadReduce 3# 154# happyReduction_402+happyReduction_402 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ HsParTy   noExtField happy_var_2) [mop happy_var_1,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_403 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_403 = happySpecReduce_1  154# happyReduction_403+happyReduction_403 happy_x_1+	 =  case happyOut209 happy_x_1 of { (HappyWrap209 happy_var_1) -> +	happyIn170+		 (mapLoc (HsSpliceTy noExtField) happy_var_1+	)}++happyReduce_404 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_404 = happySpecReduce_1  154# happyReduction_404+happyReduction_404 happy_x_1+	 =  case happyOut221 happy_x_1 of { (HappyWrap221 happy_var_1) -> +	happyIn170+		 (mapLoc (HsSpliceTy noExtField) happy_var_1+	)}++happyReduce_405 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_405 = happyMonadReduce 2# 154# happyReduction_405+happyReduction_405 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut272 happy_x_2 of { (HappyWrap272 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 $ HsTyVar noExtField IsPromoted happy_var_2) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_406 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_406 = happyMonadReduce 6# 154# happyReduction_406+happyReduction_406 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { (HappyWrap156 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut174 happy_x_5 of { (HappyWrap174 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	( addAnnotation (gl happy_var_3) AnnComma (gl happy_var_4) >>+                                ams (sLL happy_var_1 happy_var_6 $ HsExplicitTupleTy noExtField (happy_var_3 : happy_var_5))+                                    [mj AnnSimpleQuote happy_var_1,mop happy_var_2,mcp happy_var_6])}}}}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_407 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_407 = happyMonadReduce 4# 154# happyReduction_407+happyReduction_407 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut173 happy_x_3 of { (HappyWrap173 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( ams (sLL happy_var_1 happy_var_4 $ HsExplicitListTy noExtField IsPromoted happy_var_3)+                                                       [mj AnnSimpleQuote happy_var_1,mos happy_var_2,mcs happy_var_4])}}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_408 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_408 = happyMonadReduce 2# 154# happyReduction_408+happyReduction_408 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut301 happy_x_2 of { (HappyWrap301 happy_var_2) -> +	( ams (sLL happy_var_1 happy_var_2 $ HsTyVar noExtField IsPromoted happy_var_2)+                                                       [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_409 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_409 = happyMonadReduce 5# 154# happyReduction_409+happyReduction_409 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut174 happy_x_4 of { (HappyWrap174 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	( addAnnotation (gl happy_var_2) AnnComma+                                                           (gl happy_var_3) >>+                                             ams (sLL happy_var_1 happy_var_5 $ HsExplicitListTy noExtField NotPromoted (happy_var_2 : happy_var_4))+                                                 [mos happy_var_1,mcs happy_var_5])}}}}})+	) (\r -> happyReturn (happyIn170 r))++happyReduce_410 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_410 = happySpecReduce_1  154# happyReduction_410+happyReduction_410 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn170+		 (sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsNumTy (getINTEGERs happy_var_1)+                                                           (il_value (getINTEGER happy_var_1))+	)}++happyReduce_411 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_411 = happySpecReduce_1  154# happyReduction_411+happyReduction_411 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn170+		 (sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsStrTy (getSTRINGs happy_var_1)+                                                                     (getSTRING  happy_var_1)+	)}++happyReduce_412 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_412 = happySpecReduce_1  154# happyReduction_412+happyReduction_412 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn170+		 (sL1 happy_var_1 $ mkAnonWildCardTy+	)}++happyReduce_413 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_413 = happySpecReduce_1  155# happyReduction_413+happyReduction_413 happy_x_1+	 =  case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> +	happyIn171+		 (mkLHsSigType happy_var_1+	)}++happyReduce_414 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_414 = happySpecReduce_1  156# happyReduction_414+happyReduction_414 happy_x_1+	 =  case happyOut157 happy_x_1 of { (HappyWrap157 happy_var_1) -> +	happyIn172+		 ([mkLHsSigType happy_var_1]+	)}++happyReduce_415 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_415 = happyMonadReduce 3# 156# happyReduction_415+happyReduction_415 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut157 happy_x_1 of { (HappyWrap157 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut172 happy_x_3 of { (HappyWrap172 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+                                           >> return (mkLHsSigType happy_var_1 : happy_var_3))}}})+	) (\r -> happyReturn (happyIn172 r))++happyReduce_416 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_416 = happySpecReduce_1  157# happyReduction_416+happyReduction_416 happy_x_1+	 =  case happyOut174 happy_x_1 of { (HappyWrap174 happy_var_1) -> +	happyIn173+		 (happy_var_1+	)}++happyReduce_417 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_417 = happySpecReduce_0  157# happyReduction_417+happyReduction_417  =  happyIn173+		 ([]+	)++happyReduce_418 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_418 = happySpecReduce_1  158# happyReduction_418+happyReduction_418 happy_x_1+	 =  case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> +	happyIn174+		 ([happy_var_1]+	)}++happyReduce_419 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_419 = happyMonadReduce 3# 158# happyReduction_419+happyReduction_419 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut174 happy_x_3 of { (HappyWrap174 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+                                          >> return (happy_var_1 : happy_var_3))}}})+	) (\r -> happyReturn (happyIn174 r))++happyReduce_420 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_420 = happyMonadReduce 3# 159# happyReduction_420+happyReduction_420 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut156 happy_x_3 of { (HappyWrap156 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)+                                          >> return [happy_var_1,happy_var_3])}}})+	) (\r -> happyReturn (happyIn175 r))++happyReduce_421 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_421 = happyMonadReduce 3# 159# happyReduction_421+happyReduction_421 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut175 happy_x_3 of { (HappyWrap175 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)+                                          >> return (happy_var_1 : happy_var_3))}}})+	) (\r -> happyReturn (happyIn175 r))++happyReduce_422 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_422 = happySpecReduce_2  160# happyReduction_422+happyReduction_422 happy_x_2+	happy_x_1+	 =  case happyOut177 happy_x_1 of { (HappyWrap177 happy_var_1) -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	happyIn176+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_423 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_423 = happySpecReduce_0  160# happyReduction_423+happyReduction_423  =  happyIn176+		 ([]+	)++happyReduce_424 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_424 = happySpecReduce_1  161# happyReduction_424+happyReduction_424 happy_x_1+	 =  case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> +	happyIn177+		 (sL1 happy_var_1 (UserTyVar noExtField happy_var_1)+	)}++happyReduce_425 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_425 = happyMonadReduce 5# 161# happyReduction_425+happyReduction_425 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut182 happy_x_4 of { (HappyWrap182 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	( ams (sLL happy_var_1 happy_var_5  (KindedTyVar noExtField happy_var_2 happy_var_4))+                                               [mop happy_var_1,mu AnnDcolon happy_var_3+                                               ,mcp happy_var_5])}}}}})+	) (\r -> happyReturn (happyIn177 r))++happyReduce_426 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_426 = happySpecReduce_0  162# happyReduction_426+happyReduction_426  =  happyIn178+		 (noLoc ([],[])+	)++happyReduce_427 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_427 = happySpecReduce_2  162# happyReduction_427+happyReduction_427 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut179 happy_x_2 of { (HappyWrap179 happy_var_2) -> +	happyIn178+		 ((sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]+                                                 ,reverse (unLoc happy_var_2)))+	)}}++happyReduce_428 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_428 = happyMonadReduce 3# 163# happyReduction_428+happyReduction_428 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut179 happy_x_1 of { (HappyWrap179 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut180 happy_x_3 of { (HappyWrap180 happy_var_3) -> +	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2)+                           >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+	) (\r -> happyReturn (happyIn179 r))++happyReduce_429 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_429 = happySpecReduce_1  163# happyReduction_429+happyReduction_429 happy_x_1+	 =  case happyOut180 happy_x_1 of { (HappyWrap180 happy_var_1) -> +	happyIn179+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_430 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_430 = happyMonadReduce 3# 164# happyReduction_430+happyReduction_430 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut181 happy_x_1 of { (HappyWrap181 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut181 happy_x_3 of { (HappyWrap181 happy_var_3) -> +	( ams (L (comb3 happy_var_1 happy_var_2 happy_var_3)+                                       (reverse (unLoc happy_var_1), reverse (unLoc happy_var_3)))+                                       [mu AnnRarrow happy_var_2])}}})+	) (\r -> happyReturn (happyIn180 r))++happyReduce_431 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_431 = happySpecReduce_0  165# happyReduction_431+happyReduction_431  =  happyIn181+		 (noLoc []+	)++happyReduce_432 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_432 = happySpecReduce_2  165# happyReduction_432+happyReduction_432 happy_x_2+	happy_x_1+	 =  case happyOut181 happy_x_1 of { (HappyWrap181 happy_var_1) -> +	case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> +	happyIn181+		 (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+	)}}++happyReduce_433 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_433 = happySpecReduce_1  166# happyReduction_433+happyReduction_433 happy_x_1+	 =  case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> +	happyIn182+		 (happy_var_1+	)}++happyReduce_434 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_434 = happyMonadReduce 4# 167# happyReduction_434+happyReduction_434 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut184 happy_x_3 of { (HappyWrap184 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( checkEmptyGADTs $+                                                      L (comb2 happy_var_1 happy_var_3)+                                                        ([mj AnnWhere happy_var_1+                                                         ,moc happy_var_2+                                                         ,mcc happy_var_4]+                                                        , unLoc happy_var_3))}}}})+	) (\r -> happyReturn (happyIn183 r))++happyReduce_435 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_435 = happyMonadReduce 4# 167# happyReduction_435+happyReduction_435 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut184 happy_x_3 of { (HappyWrap184 happy_var_3) -> +	( checkEmptyGADTs $+                                                      L (comb2 happy_var_1 happy_var_3)+                                                        ([mj AnnWhere happy_var_1]+                                                        , unLoc happy_var_3))}})+	) (\r -> happyReturn (happyIn183 r))++happyReduce_436 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_436 = happySpecReduce_0  167# happyReduction_436+happyReduction_436  =  happyIn183+		 (noLoc ([],[])+	)++happyReduce_437 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_437 = happyMonadReduce 3# 168# happyReduction_437+happyReduction_437 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut185 happy_x_1 of { (HappyWrap185 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut184 happy_x_3 of { (HappyWrap184 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)+                     >> return (L (comb2 happy_var_1 happy_var_3) (happy_var_1 : unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn184 r))++happyReduce_438 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_438 = happySpecReduce_1  168# happyReduction_438+happyReduction_438 happy_x_1+	 =  case happyOut185 happy_x_1 of { (HappyWrap185 happy_var_1) -> +	happyIn184+		 (L (gl happy_var_1) [happy_var_1]+	)}++happyReduce_439 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_439 = happySpecReduce_0  168# happyReduction_439+happyReduction_439  =  happyIn184+		 (noLoc []+	)++happyReduce_440 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_440 = happyMonadReduce 3# 169# happyReduction_440+happyReduction_440 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> +	case happyOut186 happy_x_3 of { (HappyWrap186 happy_var_3) -> +	( return $ addConDoc happy_var_3 happy_var_1)}})+	) (\r -> happyReturn (happyIn185 r))++happyReduce_441 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_441 = happyMonadReduce 1# 169# happyReduction_441+happyReduction_441 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut186 happy_x_1 of { (HappyWrap186 happy_var_1) -> +	( return happy_var_1)})+	) (\r -> happyReturn (happyIn185 r))++happyReduce_442 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_442 = happyMonadReduce 3# 170# happyReduction_442+happyReduction_442 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut276 happy_x_1 of { (HappyWrap276 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> +	( let (gadt,anns) = mkGadtDecl (unLoc happy_var_1) happy_var_3+                   in ams (sLL happy_var_1 happy_var_3 gadt)+                       (mu AnnDcolon happy_var_2:anns))}}})+	) (\r -> happyReturn (happyIn186 r))++happyReduce_443 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_443 = happySpecReduce_3  171# happyReduction_443+happyReduction_443 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut188 happy_x_3 of { (HappyWrap188 happy_var_3) -> +	happyIn187+		 (L (comb2 happy_var_2 happy_var_3) ([mj AnnEqual happy_var_2]+                                                     ,addConDocs (unLoc happy_var_3) happy_var_1)+	)}}}++happyReduce_444 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_444 = happyMonadReduce 5# 172# happyReduction_444+happyReduction_444 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut188 happy_x_1 of { (HappyWrap188 happy_var_1) -> +	case happyOut328 happy_x_2 of { (HappyWrap328 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut327 happy_x_4 of { (HappyWrap327 happy_var_4) -> +	case happyOut189 happy_x_5 of { (HappyWrap189 happy_var_5) -> +	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_3)+               >> return (sLL happy_var_1 happy_var_5 (addConDoc happy_var_5 happy_var_2 : addConDocFirst (unLoc happy_var_1) happy_var_4)))}}}}})+	) (\r -> happyReturn (happyIn188 r))++happyReduce_445 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_445 = happySpecReduce_1  172# happyReduction_445+happyReduction_445 happy_x_1+	 =  case happyOut189 happy_x_1 of { (HappyWrap189 happy_var_1) -> +	happyIn188+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_446 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_446 = happyMonadReduce 5# 173# happyReduction_446+happyReduction_446 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> +	case happyOut190 happy_x_2 of { (HappyWrap190 happy_var_2) -> +	case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut191 happy_x_5 of { (HappyWrap191 happy_var_5) -> +	( ams (let (con,details,doc_prev) = unLoc happy_var_5 in+                  addConDoc (L (comb4 happy_var_2 happy_var_3 happy_var_4 happy_var_5) (mkConDeclH98 con+                                                       (snd $ unLoc happy_var_2)+                                                       (Just happy_var_3)+                                                       details))+                            (happy_var_1 `mplus` doc_prev))+                        (mu AnnDarrow happy_var_4:(fst $ unLoc happy_var_2)))}}}}})+	) (\r -> happyReturn (happyIn189 r))++happyReduce_447 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_447 = happyMonadReduce 3# 173# happyReduction_447+happyReduction_447 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> +	case happyOut190 happy_x_2 of { (HappyWrap190 happy_var_2) -> +	case happyOut191 happy_x_3 of { (HappyWrap191 happy_var_3) -> +	( ams ( let (con,details,doc_prev) = unLoc happy_var_3 in+                  addConDoc (L (comb2 happy_var_2 happy_var_3) (mkConDeclH98 con+                                                      (snd $ unLoc happy_var_2)+                                                      Nothing   -- No context+                                                      details))+                            (happy_var_1 `mplus` doc_prev))+                       (fst $ unLoc happy_var_2))}}})+	) (\r -> happyReturn (happyIn189 r))++happyReduce_448 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_448 = happySpecReduce_3  174# happyReduction_448+happyReduction_448 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn190+		 (sLL happy_var_1 happy_var_3 ([mu AnnForall happy_var_1,mj AnnDot happy_var_3], Just happy_var_2)+	)}}}++happyReduce_449 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_449 = happySpecReduce_0  174# happyReduction_449+happyReduction_449  =  happyIn190+		 (noLoc ([], Nothing)+	)++happyReduce_450 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_450 = happyMonadReduce 1# 175# happyReduction_450+happyReduction_450 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> +	( do { c <- mergeDataCon (unLoc happy_var_1)+                                                 ; return $ sL1 happy_var_1 c })})+	) (\r -> happyReturn (happyIn191 r))++happyReduce_451 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_451 = happySpecReduce_0  176# happyReduction_451+happyReduction_451  =  happyIn192+		 ([]+	)++happyReduce_452 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_452 = happySpecReduce_1  176# happyReduction_452+happyReduction_452 happy_x_1+	 =  case happyOut193 happy_x_1 of { (HappyWrap193 happy_var_1) -> +	happyIn192+		 (happy_var_1+	)}++happyReduce_453 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_453 = happyMonadReduce 5# 177# happyReduction_453+happyReduction_453 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut194 happy_x_1 of { (HappyWrap194 happy_var_1) -> +	case happyOut328 happy_x_2 of { (HappyWrap328 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut327 happy_x_4 of { (HappyWrap327 happy_var_4) -> +	case happyOut193 happy_x_5 of { (HappyWrap193 happy_var_5) -> +	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_3) >>+               return ((addFieldDoc happy_var_1 happy_var_4) : addFieldDocs happy_var_5 happy_var_2))}}}}})+	) (\r -> happyReturn (happyIn193 r))++happyReduce_454 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_454 = happySpecReduce_1  177# happyReduction_454+happyReduction_454 happy_x_1+	 =  case happyOut194 happy_x_1 of { (HappyWrap194 happy_var_1) -> +	happyIn193+		 ([happy_var_1]+	)}++happyReduce_455 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_455 = happyMonadReduce 5# 178# happyReduction_455+happyReduction_455 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> +	case happyOut152 happy_x_2 of { (HappyWrap152 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> +	case happyOut327 happy_x_5 of { (HappyWrap327 happy_var_5) -> +	( ams (L (comb2 happy_var_2 happy_var_4)+                      (ConDeclField noExtField (reverse (map (\ln@(L l n) -> L l $ FieldOcc noExtField ln) (unLoc happy_var_2))) happy_var_4 (happy_var_1 `mplus` happy_var_5)))+                   [mu AnnDcolon happy_var_3])}}}}})+	) (\r -> happyReturn (happyIn194 r))++happyReduce_456 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_456 = happySpecReduce_0  179# happyReduction_456+happyReduction_456  =  happyIn195+		 (noLoc []+	)++happyReduce_457 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_457 = happySpecReduce_1  179# happyReduction_457+happyReduction_457 happy_x_1+	 =  case happyOut196 happy_x_1 of { (HappyWrap196 happy_var_1) -> +	happyIn195+		 (happy_var_1+	)}++happyReduce_458 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_458 = happySpecReduce_2  180# happyReduction_458+happyReduction_458 happy_x_2+	happy_x_1+	 =  case happyOut196 happy_x_1 of { (HappyWrap196 happy_var_1) -> +	case happyOut197 happy_x_2 of { (HappyWrap197 happy_var_2) -> +	happyIn196+		 (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1+	)}}++happyReduce_459 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_459 = happySpecReduce_1  180# happyReduction_459+happyReduction_459 happy_x_1+	 =  case happyOut197 happy_x_1 of { (HappyWrap197 happy_var_1) -> +	happyIn196+		 (sLL happy_var_1 happy_var_1 [happy_var_1]+	)}++happyReduce_460 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_460 = happyMonadReduce 2# 181# happyReduction_460+happyReduction_460 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut198 happy_x_2 of { (HappyWrap198 happy_var_2) -> +	( let { full_loc = comb2 happy_var_1 happy_var_2 }+                 in ams (L full_loc $ HsDerivingClause noExtField Nothing happy_var_2)+                        [mj AnnDeriving happy_var_1])}})+	) (\r -> happyReturn (happyIn197 r))++happyReduce_461 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_461 = happyMonadReduce 3# 181# happyReduction_461+happyReduction_461 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut84 happy_x_2 of { (HappyWrap84 happy_var_2) -> +	case happyOut198 happy_x_3 of { (HappyWrap198 happy_var_3) -> +	( let { full_loc = comb2 happy_var_1 happy_var_3 }+                 in ams (L full_loc $ HsDerivingClause noExtField (Just happy_var_2) happy_var_3)+                        [mj AnnDeriving happy_var_1])}}})+	) (\r -> happyReturn (happyIn197 r))++happyReduce_462 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_462 = happyMonadReduce 3# 181# happyReduction_462+happyReduction_462 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut198 happy_x_2 of { (HappyWrap198 happy_var_2) -> +	case happyOut85 happy_x_3 of { (HappyWrap85 happy_var_3) -> +	( let { full_loc = comb2 happy_var_1 happy_var_3 }+                 in ams (L full_loc $ HsDerivingClause noExtField (Just happy_var_3) happy_var_2)+                        [mj AnnDeriving happy_var_1])}}})+	) (\r -> happyReturn (happyIn197 r))++happyReduce_463 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_463 = happySpecReduce_1  182# happyReduction_463+happyReduction_463 happy_x_1+	 =  case happyOut287 happy_x_1 of { (HappyWrap287 happy_var_1) -> +	happyIn198+		 (sL1 happy_var_1 [mkLHsSigType happy_var_1]+	)}++happyReduce_464 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_464 = happyMonadReduce 2# 182# happyReduction_464+happyReduction_464 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 [])+                                     [mop happy_var_1,mcp happy_var_2])}})+	) (\r -> happyReturn (happyIn198 r))++happyReduce_465 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_465 = happyMonadReduce 3# 182# happyReduction_465+happyReduction_465 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut172 happy_x_2 of { (HappyWrap172 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 happy_var_2)+                                     [mop happy_var_1,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn198 r))++happyReduce_466 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_466 = happySpecReduce_1  183# happyReduction_466+happyReduction_466 happy_x_1+	 =  case happyOut200 happy_x_1 of { (HappyWrap200 happy_var_1) -> +	happyIn199+		 (sL1 happy_var_1 (DocD noExtField (unLoc happy_var_1))+	)}++happyReduce_467 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_467 = happySpecReduce_1  184# happyReduction_467+happyReduction_467 happy_x_1+	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> +	happyIn200+		 (sL1 happy_var_1 (DocCommentNext (unLoc happy_var_1))+	)}++happyReduce_468 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_468 = happySpecReduce_1  184# happyReduction_468+happyReduction_468 happy_x_1+	 =  case happyOut323 happy_x_1 of { (HappyWrap323 happy_var_1) -> +	happyIn200+		 (sL1 happy_var_1 (DocCommentPrev (unLoc happy_var_1))+	)}++happyReduce_469 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_469 = happySpecReduce_1  184# happyReduction_469+happyReduction_469 happy_x_1+	 =  case happyOut324 happy_x_1 of { (HappyWrap324 happy_var_1) -> +	happyIn200+		 (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocCommentNamed n doc)+	)}++happyReduce_470 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_470 = happySpecReduce_1  184# happyReduction_470+happyReduction_470 happy_x_1+	 =  case happyOut325 happy_x_1 of { (HappyWrap325 happy_var_1) -> +	happyIn200+		 (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocGroup n doc)+	)}++happyReduce_471 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_471 = happySpecReduce_1  185# happyReduction_471+happyReduction_471 happy_x_1+	 =  case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> +	happyIn201+		 (happy_var_1+	)}++happyReduce_472 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_472 = happyMonadReduce 3# 185# happyReduction_472+happyReduction_472 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOut148 happy_x_2 of { (HappyWrap148 happy_var_2) -> +	case happyOut203 happy_x_3 of { (HappyWrap203 happy_var_3) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                       do { (ann,r) <- checkValDef happy_var_1 (snd happy_var_2) happy_var_3;+                                        let { l = comb2 happy_var_1 happy_var_3 };+                                        -- Depending upon what the pattern looks like we might get either+                                        -- a FunBind or PatBind back from checkValDef. See Note+                                        -- [FunBind vs PatBind]+                                        case r of {+                                          (FunBind _ n _ _) ->+                                                amsL l (mj AnnFunId n:(fst happy_var_2)) >> return () ;+                                          (PatBind _ (L lh _lhs) _rhs _) ->+                                                amsL lh (fst happy_var_2) >> return () } ;+                                        _ <- amsL l (ann ++ (fst $ unLoc happy_var_3));+                                        return $! (sL l $ ValD noExtField r) })}}})+	) (\r -> happyReturn (happyIn201 r))++happyReduce_473 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_473 = happySpecReduce_1  185# happyReduction_473+happyReduction_473 happy_x_1+	 =  case happyOut111 happy_x_1 of { (HappyWrap111 happy_var_1) -> +	happyIn201+		 (happy_var_1+	)}++happyReduce_474 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_474 = happySpecReduce_1  185# happyReduction_474+happyReduction_474 happy_x_1+	 =  case happyOut199 happy_x_1 of { (HappyWrap199 happy_var_1) -> +	happyIn201+		 (happy_var_1+	)}++happyReduce_475 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_475 = happySpecReduce_1  186# happyReduction_475+happyReduction_475 happy_x_1+	 =  case happyOut201 happy_x_1 of { (HappyWrap201 happy_var_1) -> +	happyIn202+		 (happy_var_1+	)}++happyReduce_476 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_476 = happySpecReduce_1  186# happyReduction_476+happyReduction_476 happy_x_1+	 =  case happyOut220 happy_x_1 of { (HappyWrap220 happy_var_1) -> +	happyIn202+		 (sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1+	)}++happyReduce_477 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_477 = happyMonadReduce 3# 187# happyReduction_477+happyReduction_477 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	case happyOut128 happy_x_3 of { (HappyWrap128 happy_var_3) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 -> return $+                                  sL (comb3 happy_var_1 happy_var_2 happy_var_3)+                                    ((mj AnnEqual happy_var_1 : (fst $ unLoc happy_var_3))+                                    ,GRHSs noExtField (unguardedRHS (comb3 happy_var_1 happy_var_2 happy_var_3) happy_var_2)+                                   (snd $ unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn203 r))++happyReduce_478 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_478 = happySpecReduce_2  187# happyReduction_478+happyReduction_478 happy_x_2+	happy_x_1+	 =  case happyOut204 happy_x_1 of { (HappyWrap204 happy_var_1) -> +	case happyOut128 happy_x_2 of { (HappyWrap128 happy_var_2) -> +	happyIn203+		 (sLL happy_var_1 happy_var_2  (fst $ unLoc happy_var_2+                                    ,GRHSs noExtField (reverse (unLoc happy_var_1))+                                                    (snd $ unLoc happy_var_2))+	)}}++happyReduce_479 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_479 = happySpecReduce_2  188# happyReduction_479+happyReduction_479 happy_x_2+	happy_x_1+	 =  case happyOut204 happy_x_1 of { (HappyWrap204 happy_var_1) -> +	case happyOut205 happy_x_2 of { (HappyWrap205 happy_var_2) -> +	happyIn204+		 (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)+	)}}++happyReduce_480 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_480 = happySpecReduce_1  188# happyReduction_480+happyReduction_480 happy_x_1+	 =  case happyOut205 happy_x_1 of { (HappyWrap205 happy_var_1) -> +	happyIn204+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_481 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_481 = happyMonadReduce 4# 189# happyReduction_481+happyReduction_481 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	( runECP_P happy_var_4 >>= \ happy_var_4 ->+                                     ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS noExtField (unLoc happy_var_2) happy_var_4)+                                         [mj AnnVbar happy_var_1,mj AnnEqual happy_var_3])}}}})+	) (\r -> happyReturn (happyIn205 r))++happyReduce_482 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_482 = happyMonadReduce 3# 190# happyReduction_482+happyReduction_482 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> +	( do { happy_var_1 <- runECP_P happy_var_1+                              ; v <- checkValSigLhs happy_var_1+                              ; _ <- amsL (comb2 happy_var_1 happy_var_3) [mu AnnDcolon happy_var_2]+                              ; return (sLL happy_var_1 happy_var_3 $ SigD noExtField $+                                  TypeSig noExtField [v] (mkLHsSigWcType happy_var_3))})}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_483 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_483 = happyMonadReduce 5# 190# happyReduction_483+happyReduction_483 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut152 happy_x_3 of { (HappyWrap152 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut151 happy_x_5 of { (HappyWrap151 happy_var_5) -> +	( do { let sig = TypeSig noExtField (happy_var_1 : reverse (unLoc happy_var_3))+                                     (mkLHsSigWcType happy_var_5)+                 ; addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)+                 ; ams ( sLL happy_var_1 happy_var_5 $ SigD noExtField sig )+                       [mu AnnDcolon happy_var_4] })}}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_484 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_484 = happyMonadReduce 3# 190# happyReduction_484+happyReduction_484 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut73 happy_x_1 of { (HappyWrap73 happy_var_1) -> +	case happyOut72 happy_x_2 of { (HappyWrap72 happy_var_2) -> +	case happyOut74 happy_x_3 of { (HappyWrap74 happy_var_3) -> +	( checkPrecP happy_var_2 happy_var_3 >>+                 ams (sLL happy_var_1 happy_var_3 $ SigD noExtField+                        (FixSig noExtField (FixitySig noExtField (fromOL $ unLoc happy_var_3)+                                (Fixity (fst $ unLoc happy_var_2) (snd $ unLoc happy_var_2) (unLoc happy_var_1)))))+                     [mj AnnInfix happy_var_1,mj AnnVal happy_var_2])}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_485 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_485 = happySpecReduce_1  190# happyReduction_485+happyReduction_485 happy_x_1+	 =  case happyOut116 happy_x_1 of { (HappyWrap116 happy_var_1) -> +	happyIn206+		 (sLL happy_var_1 happy_var_1 . SigD noExtField . unLoc $ happy_var_1+	)}++happyReduce_486 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_486 = happyMonadReduce 4# 190# happyReduction_486+happyReduction_486 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut276 happy_x_2 of { (HappyWrap276 happy_var_2) -> +	case happyOut149 happy_x_3 of { (HappyWrap149 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( let (dcolon, tc) = happy_var_3+                   in ams+                       (sLL happy_var_1 happy_var_4+                         (SigD noExtField (CompleteMatchSig noExtField (getCOMPLETE_PRAGs happy_var_1) happy_var_2 tc)))+                    ([ mo happy_var_1 ] ++ dcolon ++ [mc happy_var_4]))}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_487 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_487 = happyMonadReduce 4# 190# happyReduction_487+happyReduction_487 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> +	case happyOut302 happy_x_3 of { (HappyWrap302 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( ams ((sLL happy_var_1 happy_var_4 $ SigD noExtField (InlineSig noExtField happy_var_3+                            (mkInlinePragma (getINLINE_PRAGs happy_var_1) (getINLINE happy_var_1)+                                            (snd happy_var_2)))))+                       ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_4]))}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_488 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_488 = happyMonadReduce 3# 190# happyReduction_488+happyReduction_488 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (SigD noExtField (SCCFunSig noExtField (getSCC_PRAGs happy_var_1) happy_var_2 Nothing)))+                 [mo happy_var_1, mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_489 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_489 = happyMonadReduce 4# 190# happyReduction_489+happyReduction_489 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( do { scc <- getSCC happy_var_3+                ; let str_lit = StringLiteral (getSTRINGs happy_var_3) scc+                ; ams (sLL happy_var_1 happy_var_4 (SigD noExtField (SCCFunSig noExtField (getSCC_PRAGs happy_var_1) happy_var_2 (Just ( sL1 happy_var_3 str_lit)))))+                      [mo happy_var_1, mc happy_var_4] })}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_490 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_490 = happyMonadReduce 6# 190# happyReduction_490+happyReduction_490 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> +	case happyOut302 happy_x_3 of { (HappyWrap302 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut153 happy_x_5 of { (HappyWrap153 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	( ams (+                 let inl_prag = mkInlinePragma (getSPEC_PRAGs happy_var_1)+                                             (NoUserInline, FunLike) (snd happy_var_2)+                  in sLL happy_var_1 happy_var_6 $ SigD noExtField (SpecSig noExtField happy_var_3 (fromOL happy_var_5) inl_prag))+                    (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_491 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_491 = happyMonadReduce 6# 190# happyReduction_491+happyReduction_491 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> +	case happyOut302 happy_x_3 of { (HappyWrap302 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut153 happy_x_5 of { (HappyWrap153 happy_var_5) -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	( ams (sLL happy_var_1 happy_var_6 $ SigD noExtField (SpecSig noExtField happy_var_3 (fromOL happy_var_5)+                               (mkInlinePragma (getSPEC_INLINE_PRAGs happy_var_1)+                                               (getSPEC_INLINE happy_var_1) (snd happy_var_2))))+                       (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_492 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_492 = happyMonadReduce 4# 190# happyReduction_492+happyReduction_492 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut171 happy_x_3 of { (HappyWrap171 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( ams (sLL happy_var_1 happy_var_4+                                  $ SigD noExtField (SpecInstSig noExtField (getSPEC_PRAGs happy_var_1) happy_var_3))+                       [mo happy_var_1,mj AnnInstance happy_var_2,mc happy_var_4])}}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_493 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_493 = happyMonadReduce 3# 190# happyReduction_493+happyReduction_493 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut265 happy_x_2 of { (HappyWrap265 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ SigD noExtField (MinimalSig noExtField (getMINIMAL_PRAGs happy_var_1) happy_var_2))+                   [mo happy_var_1,mc happy_var_3])}}})+	) (\r -> happyReturn (happyIn206 r))++happyReduce_494 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_494 = happySpecReduce_0  191# happyReduction_494+happyReduction_494  =  happyIn207+		 (([],Nothing)+	)++happyReduce_495 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_495 = happySpecReduce_1  191# happyReduction_495+happyReduction_495 happy_x_1+	 =  case happyOut208 happy_x_1 of { (HappyWrap208 happy_var_1) -> +	happyIn207+		 ((fst happy_var_1,Just (snd happy_var_1))+	)}++happyReduce_496 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_496 = happySpecReduce_3  192# happyReduction_496+happyReduction_496 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn208+		 (([mj AnnOpenS happy_var_1,mj AnnVal happy_var_2,mj AnnCloseS happy_var_3]+                                  ,ActiveAfter  (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))+	)}}}++happyReduce_497 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_497 = happyReduce 4# 192# happyReduction_497+happyReduction_497 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn208+		 ((happy_var_2++[mj AnnOpenS happy_var_1,mj AnnVal happy_var_3,mj AnnCloseS happy_var_4]+                                  ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))+	) `HappyStk` happyRest}}}}++happyReduce_498 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_498 = happySpecReduce_1  193# happyReduction_498+happyReduction_498 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn209+		 (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 (mkSrcSpanPs quoteSpan) quote)+	)}++happyReduce_499 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_499 = happySpecReduce_1  193# happyReduction_499+happyReduction_499 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn209+		 (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 (mkSrcSpanPs quoteSpan) quote)+	)}++happyReduce_500 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_500 = happySpecReduce_3  194# happyReduction_500+happyReduction_500 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut150 happy_x_3 of { (HappyWrap150 happy_var_3) -> +	happyIn210+		 (ECP $+                                   runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                   rejectPragmaPV happy_var_1 >>+                                   amms (mkHsTySigPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_3)+                                       [mu AnnDcolon happy_var_2]+	)}}}++happyReduce_501 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_501 = happyMonadReduce 3# 194# happyReduction_501+happyReduction_501 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                   runECP_P happy_var_3 >>= \ happy_var_3 ->+                                   fmap ecpFromCmd $+                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_1 happy_var_3+                                                        HsFirstOrderApp True)+                                       [mu Annlarrowtail happy_var_2])}}})+	) (\r -> happyReturn (happyIn210 r))++happyReduce_502 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_502 = happyMonadReduce 3# 194# happyReduction_502+happyReduction_502 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                   runECP_P happy_var_3 >>= \ happy_var_3 ->+                                   fmap ecpFromCmd $+                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_3 happy_var_1+                                                      HsFirstOrderApp False)+                                       [mu Annrarrowtail happy_var_2])}}})+	) (\r -> happyReturn (happyIn210 r))++happyReduce_503 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_503 = happyMonadReduce 3# 194# happyReduction_503+happyReduction_503 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                   runECP_P happy_var_3 >>= \ happy_var_3 ->+                                   fmap ecpFromCmd $+                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_1 happy_var_3+                                                      HsHigherOrderApp True)+                                       [mu AnnLarrowtail happy_var_2])}}})+	) (\r -> happyReturn (happyIn210 r))++happyReduce_504 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_504 = happyMonadReduce 3# 194# happyReduction_504+happyReduction_504 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                   runECP_P happy_var_3 >>= \ happy_var_3 ->+                                   fmap ecpFromCmd $+                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_3 happy_var_1+                                                      HsHigherOrderApp False)+                                       [mu AnnRarrowtail happy_var_2])}}})+	) (\r -> happyReturn (happyIn210 r))++happyReduce_505 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_505 = happySpecReduce_1  194# happyReduction_505+happyReduction_505 happy_x_1+	 =  case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	happyIn210+		 (happy_var_1+	)}++happyReduce_506 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_506 = happySpecReduce_1  194# happyReduction_506+happyReduction_506 happy_x_1+	 =  case happyOut329 happy_x_1 of { (HappyWrap329 happy_var_1) -> +	happyIn210+		 (happy_var_1+	)}++happyReduce_507 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_507 = happySpecReduce_1  195# happyReduction_507+happyReduction_507 happy_x_1+	 =  case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> +	happyIn211+		 (happy_var_1+	)}++happyReduce_508 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_508 = happySpecReduce_3  195# happyReduction_508+happyReduction_508 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOut293 happy_x_2 of { (HappyWrap293 happy_var_2) -> +	case happyOut212 happy_x_3 of { (HappyWrap212 happy_var_3) -> +	happyIn211+		 (ECP $+                                 superInfixOp $+                                 happy_var_2 >>= \ happy_var_2 ->+                                 runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                 runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                 rejectPragmaPV happy_var_1 >>+                                 amms (mkHsOpAppPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_2 happy_var_3)+                                     [mj AnnVal happy_var_2]+	)}}}++happyReduce_509 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_509 = happySpecReduce_1  196# happyReduction_509+happyReduction_509 happy_x_1+	 =  case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> +	happyIn212+		 (happy_var_1+	)}++happyReduce_510 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_510 = happySpecReduce_1  196# happyReduction_510+happyReduction_510 happy_x_1+	 =  case happyOut330 happy_x_1 of { (HappyWrap330 happy_var_1) -> +	happyIn212+		 (happy_var_1+	)}++happyReduce_511 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_511 = happySpecReduce_2  197# happyReduction_511+happyReduction_511 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut216 happy_x_2 of { (HappyWrap216 happy_var_2) -> +	happyIn213+		 (ECP $+                                           runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                           amms (mkHsNegAppPV (comb2 happy_var_1 happy_var_2) happy_var_2)+                                               [mj AnnMinus happy_var_1]+	)}}++happyReduce_512 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_512 = happySpecReduce_1  197# happyReduction_512+happyReduction_512 happy_x_1+	 =  case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> +	happyIn213+		 (happy_var_1+	)}++happyReduce_513 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_513 = happySpecReduce_1  198# happyReduction_513+happyReduction_513 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn214+		 (([happy_var_1],True)+	)}++happyReduce_514 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_514 = happySpecReduce_0  198# happyReduction_514+happyReduction_514  =  happyIn214+		 (([],False)+	)++happyReduce_515 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_515 = happyMonadReduce 3# 199# happyReduction_515+happyReduction_515 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( do scc <- getSCC happy_var_2+                                          ; return $ sLL happy_var_1 happy_var_3+                                             ([mo happy_var_1,mj AnnValStr happy_var_2,mc happy_var_3],+                                              HsPragSCC noExtField+                                                (getSCC_PRAGs happy_var_1)+                                                (StringLiteral (getSTRINGs happy_var_2) scc)))}}})+	) (\r -> happyReturn (happyIn215 r))++happyReduce_516 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_516 = happySpecReduce_3  199# happyReduction_516+happyReduction_516 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn215+		 (sLL happy_var_1 happy_var_3 ([mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3],+                                                  HsPragSCC noExtField+                                                    (getSCC_PRAGs happy_var_1)+                                                    (StringLiteral NoSourceText (getVARID happy_var_2)))+	)}}}++happyReduce_517 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_517 = happyReduce 10# 199# happyReduction_517+happyReduction_517 (happy_x_10 `HappyStk`+	happy_x_9 `HappyStk`+	happy_x_8 `HappyStk`+	happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	case happyOutTok happy_x_6 of { happy_var_6 -> +	case happyOutTok happy_x_7 of { happy_var_7 -> +	case happyOutTok happy_x_8 of { happy_var_8 -> +	case happyOutTok happy_x_9 of { happy_var_9 -> +	case happyOutTok happy_x_10 of { happy_var_10 -> +	happyIn215+		 (let getINT = fromInteger . il_value . getINTEGER in+                                        sLL happy_var_1 happy_var_10 $ ([mo happy_var_1,mj AnnVal happy_var_2+                                              ,mj AnnVal happy_var_3,mj AnnColon happy_var_4+                                              ,mj AnnVal happy_var_5,mj AnnMinus happy_var_6+                                              ,mj AnnVal happy_var_7,mj AnnColon happy_var_8+                                              ,mj AnnVal happy_var_9,mc happy_var_10],+                                              HsPragTick noExtField+                                                (getGENERATED_PRAGs happy_var_1)+                                                (getStringLiteral happy_var_2,+                                                 (getINT happy_var_3, getINT happy_var_5),+                                                 (getINT happy_var_7, getINT happy_var_9))+                                                ((getINTEGERs happy_var_3, getINTEGERs happy_var_5),+                                                 (getINTEGERs happy_var_7, getINTEGERs happy_var_9) ))+	) `HappyStk` happyRest}}}}}}}}}}++happyReduce_518 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_518 = happySpecReduce_3  199# happyReduction_518+happyReduction_518 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn215+		 (sLL happy_var_1 happy_var_3 $+            ([mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3],+             HsPragCore noExtField (getCORE_PRAGs happy_var_1) (getStringLiteral happy_var_2))+	)}}}++happyReduce_519 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_519 = happySpecReduce_2  200# happyReduction_519+happyReduction_519 happy_x_2+	happy_x_1+	 =  case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> +	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> +	happyIn216+		 (ECP $+                                          superFunArg $+                                          runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                          runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                          mkHsAppPV (comb2 happy_var_1 happy_var_2) happy_var_1 happy_var_2+	)}}++happyReduce_520 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_520 = happyMonadReduce 3# 200# happyReduction_520+happyReduction_520 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut170 happy_x_3 of { (HappyWrap170 happy_var_3) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                        runPV (checkExpBlockArguments happy_var_1) >>= \_ ->+                                        fmap ecpFromExp $+                                        ams (sLL happy_var_1 happy_var_3 $ HsAppType noExtField happy_var_1 (mkHsWildCardBndrs happy_var_3))+                                            [mj AnnAt happy_var_2])}}})+	) (\r -> happyReturn (happyIn216 r))++happyReduce_521 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_521 = happyMonadReduce 2# 200# happyReduction_521+happyReduction_521 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                        fmap ecpFromExp $+                                        ams (sLL happy_var_1 happy_var_2 $ HsStatic noExtField happy_var_2)+                                            [mj AnnStatic happy_var_1])}})+	) (\r -> happyReturn (happyIn216 r))++happyReduce_522 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_522 = happySpecReduce_1  200# happyReduction_522+happyReduction_522 happy_x_1+	 =  case happyOut217 happy_x_1 of { (HappyWrap217 happy_var_1) -> +	happyIn216+		 (happy_var_1+	)}++happyReduce_523 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_523 = happySpecReduce_3  201# happyReduction_523+happyReduction_523 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut217 happy_x_3 of { (HappyWrap217 happy_var_3) -> +	happyIn217+		 (ECP $+                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                   amms (mkHsAsPatPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_3) [mj AnnAt happy_var_2]+	)}}}++happyReduce_524 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_524 = happySpecReduce_2  201# happyReduction_524+happyReduction_524 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> +	happyIn217+		 (ECP $+                                   runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                   amms (mkHsLazyPatPV (comb2 happy_var_1 happy_var_2) happy_var_2) [mj AnnTilde happy_var_1]+	)}}++happyReduce_525 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_525 = happySpecReduce_2  201# happyReduction_525+happyReduction_525 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> +	happyIn217+		 (ECP $+                                   runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                   amms (mkHsBangPatPV (comb2 happy_var_1 happy_var_2) happy_var_2) [mj AnnBang happy_var_1]+	)}}++happyReduce_526 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_526 = happyReduce 5# 201# happyReduction_526+happyReduction_526 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut250 happy_x_2 of { (HappyWrap250 happy_var_2) -> +	case happyOut251 happy_x_3 of { (HappyWrap251 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut210 happy_x_5 of { (HappyWrap210 happy_var_5) -> +	happyIn217+		 (ECP $+                      runECP_PV happy_var_5 >>= \ happy_var_5 ->+                      amms (mkHsLamPV (comb2 happy_var_1 happy_var_5) (mkMatchGroup FromSource+                            [sLL happy_var_1 happy_var_5 $ Match { m_ext = noExtField+                                               , m_ctxt = LambdaExpr+                                               , m_pats = happy_var_2:happy_var_3+                                               , m_grhss = unguardedGRHSs happy_var_5 }]))+                          [mj AnnLam happy_var_1, mu AnnRarrow happy_var_4]+	) `HappyStk` happyRest}}}}}++happyReduce_527 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_527 = happyReduce 4# 201# happyReduction_527+happyReduction_527 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	happyIn217+		 (ECP $+                                           runECP_PV happy_var_4 >>= \ happy_var_4 ->+                                           amms (mkHsLetPV (comb2 happy_var_1 happy_var_4) (snd (unLoc happy_var_2)) happy_var_4)+                                               (mj AnnLet happy_var_1:mj AnnIn happy_var_3+                                                 :(fst $ unLoc happy_var_2))+	) `HappyStk` happyRest}}}}++happyReduce_528 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_528 = happySpecReduce_3  201# happyReduction_528+happyReduction_528 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut239 happy_x_3 of { (HappyWrap239 happy_var_3) -> +	happyIn217+		 (ECP $ happy_var_3 >>= \ happy_var_3 ->+               amms (mkHsLamCasePV (comb2 happy_var_1 happy_var_3)+                                   (mkMatchGroup FromSource (snd $ unLoc happy_var_3)))+                    (mj AnnLam happy_var_1:mj AnnCase happy_var_2:(fst $ unLoc happy_var_3))+	)}}}++happyReduce_529 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_529 = happyMonadReduce 8# 201# happyReduction_529+happyReduction_529 (happy_x_8 `HappyStk`+	happy_x_7 `HappyStk`+	happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	case happyOut214 happy_x_3 of { (HappyWrap214 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut210 happy_x_5 of { (HappyWrap210 happy_var_5) -> +	case happyOut214 happy_x_6 of { (HappyWrap214 happy_var_6) -> +	case happyOutTok happy_x_7 of { happy_var_7 -> +	case happyOut210 happy_x_8 of { (HappyWrap210 happy_var_8) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                            return $ ECP $+                              runECP_PV happy_var_5 >>= \ happy_var_5 ->+                              runECP_PV happy_var_8 >>= \ happy_var_8 ->+                              amms (mkHsIfPV (comb2 happy_var_1 happy_var_8) happy_var_2 (snd happy_var_3) happy_var_5 (snd happy_var_6) happy_var_8)+                                  (mj AnnIf happy_var_1:mj AnnThen happy_var_4+                                     :mj AnnElse happy_var_7+                                     :(map (\l -> mj AnnSemi l) (fst happy_var_3))+                                    ++(map (\l -> mj AnnSemi l) (fst happy_var_6))))}}}}}}}})+	) (\r -> happyReturn (happyIn217 r))++happyReduce_530 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_530 = happyMonadReduce 2# 201# happyReduction_530+happyReduction_530 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut246 happy_x_2 of { (HappyWrap246 happy_var_2) -> +	( hintMultiWayIf (getLoc happy_var_1) >>= \_ ->+                                           fmap ecpFromExp $+                                           ams (sLL happy_var_1 happy_var_2 $ HsMultiIf noExtField+                                                     (reverse $ snd $ unLoc happy_var_2))+                                               (mj AnnIf happy_var_1:(fst $ unLoc happy_var_2)))}})+	) (\r -> happyReturn (happyIn217 r))++happyReduce_531 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_531 = happyMonadReduce 4# 201# happyReduction_531+happyReduction_531 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut239 happy_x_4 of { (HappyWrap239 happy_var_4) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                         return $ ECP $+                                           happy_var_4 >>= \ happy_var_4 ->+                                           amms (mkHsCasePV (comb3 happy_var_1 happy_var_3 happy_var_4) happy_var_2 (mkMatchGroup+                                                   FromSource (snd $ unLoc happy_var_4)))+                                               (mj AnnCase happy_var_1:mj AnnOf happy_var_3+                                                  :(fst $ unLoc happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn217 r))++happyReduce_532 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_532 = happySpecReduce_2  201# happyReduction_532+happyReduction_532 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut252 happy_x_2 of { (HappyWrap252 happy_var_2) -> +	happyIn217+		 (ECP $+                                        happy_var_2 >>= \ happy_var_2 ->+                                        amms (mkHsDoPV (comb2 happy_var_1 happy_var_2) (mapLoc snd happy_var_2))+                                               (mj AnnDo happy_var_1:(fst $ unLoc happy_var_2))+	)}}++happyReduce_533 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_533 = happyMonadReduce 2# 201# happyReduction_533+happyReduction_533 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut252 happy_x_2 of { (HappyWrap252 happy_var_2) -> +	( runPV happy_var_2 >>= \ happy_var_2 ->+                                       fmap ecpFromExp $+                                       ams (L (comb2 happy_var_1 happy_var_2)+                                              (mkHsDo MDoExpr (snd $ unLoc happy_var_2)))+                                           (mj AnnMdo happy_var_1:(fst $ unLoc happy_var_2)))}})+	) (\r -> happyReturn (happyIn217 r))++happyReduce_534 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_534 = happyMonadReduce 4# 201# happyReduction_534+happyReduction_534 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	( (checkPattern <=< runECP_P) happy_var_2 >>= \ p ->+                           runECP_P happy_var_4 >>= \ happy_var_4@cmd ->+                           fmap ecpFromExp $+                           ams (sLL happy_var_1 happy_var_4 $ HsProc noExtField p (sLL happy_var_1 happy_var_4 $ HsCmdTop noExtField cmd))+                                            -- TODO: is LL right here?+                               [mj AnnProc happy_var_1,mu AnnRarrow happy_var_3])}}}})+	) (\r -> happyReturn (happyIn217 r))++happyReduce_535 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_535 = happySpecReduce_1  201# happyReduction_535+happyReduction_535 happy_x_1+	 =  case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> +	happyIn217+		 (happy_var_1+	)}++happyReduce_536 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_536 = happyReduce 4# 202# happyReduction_536+happyReduction_536 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut258 happy_x_3 of { (HappyWrap258 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn218+		 (ECP $+                                  runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                  happy_var_3 >>= \ happy_var_3 ->+                                  amms (mkHsRecordPV (comb2 happy_var_1 happy_var_4) (comb2 happy_var_2 happy_var_4) happy_var_1 (snd happy_var_3))+                                       (moc happy_var_2:mcc happy_var_4:(fst happy_var_3))+	) `HappyStk` happyRest}}}}++happyReduce_537 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_537 = happySpecReduce_1  202# happyReduction_537+happyReduction_537 happy_x_1+	 =  case happyOut219 happy_x_1 of { (HappyWrap219 happy_var_1) -> +	happyIn218+		 (happy_var_1+	)}++happyReduce_538 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_538 = happySpecReduce_1  203# happyReduction_538+happyReduction_538 happy_x_1+	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> +	happyIn219+		 (ECP $ mkHsVarPV $! happy_var_1+	)}++happyReduce_539 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_539 = happySpecReduce_1  203# happyReduction_539+happyReduction_539 happy_x_1+	 =  case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> +	happyIn219+		 (ECP $ mkHsVarPV $! happy_var_1+	)}++happyReduce_540 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_540 = happySpecReduce_1  203# happyReduction_540+happyReduction_540 happy_x_1+	 =  case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> +	happyIn219+		 (ecpFromExp $ sL1 happy_var_1 (HsIPVar noExtField $! unLoc happy_var_1)+	)}++happyReduce_541 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_541 = happySpecReduce_1  203# happyReduction_541+happyReduction_541 happy_x_1+	 =  case happyOut264 happy_x_1 of { (HappyWrap264 happy_var_1) -> +	happyIn219+		 (ecpFromExp $ sL1 happy_var_1 (HsOverLabel noExtField Nothing $! unLoc happy_var_1)+	)}++happyReduce_542 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_542 = happySpecReduce_1  203# happyReduction_542+happyReduction_542 happy_x_1+	 =  case happyOut316 happy_x_1 of { (HappyWrap316 happy_var_1) -> +	happyIn219+		 (ECP $ mkHsLitPV $! happy_var_1+	)}++happyReduce_543 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_543 = happySpecReduce_1  203# happyReduction_543+happyReduction_543 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn219+		 (ECP $ mkHsOverLitPV (sL1 happy_var_1 $ mkHsIntegral   (getINTEGER  happy_var_1))+	)}++happyReduce_544 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_544 = happySpecReduce_1  203# happyReduction_544+happyReduction_544 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn219+		 (ECP $ mkHsOverLitPV (sL1 happy_var_1 $ mkHsFractional (getRATIONAL happy_var_1))+	)}++happyReduce_545 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_545 = happySpecReduce_3  203# happyReduction_545+happyReduction_545 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn219+		 (ECP $+                                           runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                           amms (mkHsParPV (comb2 happy_var_1 happy_var_3) happy_var_2) [mop happy_var_1,mcp happy_var_3]+	)}}}++happyReduce_546 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_546 = happySpecReduce_3  203# happyReduction_546+happyReduction_546 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut228 happy_x_2 of { (HappyWrap228 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn219+		 (ECP $+                                           happy_var_2 >>= \ happy_var_2 ->+                                           amms (mkSumOrTuplePV (comb2 happy_var_1 happy_var_3) Boxed (snd happy_var_2))+                                                ((mop happy_var_1:fst happy_var_2) ++ [mcp happy_var_3])+	)}}}++happyReduce_547 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_547 = happySpecReduce_3  203# happyReduction_547+happyReduction_547 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn219+		 (ECP $+                                           runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                           amms (mkSumOrTuplePV (comb2 happy_var_1 happy_var_3) Unboxed (Tuple [L (gl happy_var_2) (Just happy_var_2)]))+                                                [mo happy_var_1,mc happy_var_3]+	)}}}++happyReduce_548 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_548 = happySpecReduce_3  203# happyReduction_548+happyReduction_548 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut228 happy_x_2 of { (HappyWrap228 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn219+		 (ECP $+                                           happy_var_2 >>= \ happy_var_2 ->+                                           amms (mkSumOrTuplePV (comb2 happy_var_1 happy_var_3) Unboxed (snd happy_var_2))+                                                ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_3])+	)}}}++happyReduce_549 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_549 = happySpecReduce_3  203# happyReduction_549+happyReduction_549 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut231 happy_x_2 of { (HappyWrap231 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn219+		 (ECP $ happy_var_2 (comb2 happy_var_1 happy_var_3) >>= \a -> ams a [mos happy_var_1,mcs happy_var_3]+	)}}}++happyReduce_550 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_550 = happySpecReduce_1  203# happyReduction_550+happyReduction_550 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn219+		 (ECP $ mkHsWildCardPV (getLoc happy_var_1)+	)}++happyReduce_551 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_551 = happySpecReduce_1  203# happyReduction_551+happyReduction_551 happy_x_1+	 =  case happyOut221 happy_x_1 of { (HappyWrap221 happy_var_1) -> +	happyIn219+		 (ECP $ mkHsSplicePV happy_var_1+	)}++happyReduce_552 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_552 = happySpecReduce_1  203# happyReduction_552+happyReduction_552 happy_x_1+	 =  case happyOut222 happy_x_1 of { (HappyWrap222 happy_var_1) -> +	happyIn219+		 (ecpFromExp $ mapLoc (HsSpliceE noExtField) happy_var_1+	)}++happyReduce_553 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_553 = happyMonadReduce 2# 203# happyReduction_553+happyReduction_553 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> +	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField True  (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_554 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_554 = happyMonadReduce 2# 203# happyReduction_554+happyReduction_554 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut273 happy_x_2 of { (HappyWrap273 happy_var_2) -> +	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField True  (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_555 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_555 = happyMonadReduce 2# 203# happyReduction_555+happyReduction_555 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> +	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_556 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_556 = happyMonadReduce 2# 203# happyReduction_556+happyReduction_556 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut281 happy_x_2 of { (HappyWrap281 happy_var_2) -> +	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_557 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_557 = happyMonadReduce 1# 203# happyReduction_557+happyReduction_557 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( reportEmptyDoubleQuotes (getLoc happy_var_1))})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_558 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_558 = happyMonadReduce 3# 203# happyReduction_558+happyReduction_558 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                 fmap ecpFromExp $+                                 ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (ExpBr noExtField happy_var_2))+                                      (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1, mu AnnCloseQ happy_var_3]+                                                    else [mu AnnOpenEQ happy_var_1,mu AnnCloseQ happy_var_3]))}}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_559 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_559 = happyMonadReduce 3# 203# happyReduction_559+happyReduction_559 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                 fmap ecpFromExp $+                                 ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (TExpBr noExtField happy_var_2))+                                      (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1,mc happy_var_3] else [mo happy_var_1,mc happy_var_3]))}}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_560 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_560 = happyMonadReduce 3# 203# happyReduction_560+happyReduction_560 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( fmap ecpFromExp $+                                 ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (TypBr noExtField happy_var_2)) [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_561 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_561 = happyMonadReduce 3# 203# happyReduction_561+happyReduction_561 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut211 happy_x_2 of { (HappyWrap211 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( (checkPattern <=< runECP_P) happy_var_2 >>= \p ->+                                      fmap ecpFromExp $+                                      ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (PatBr noExtField p))+                                          [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_562 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_562 = happyMonadReduce 3# 203# happyReduction_562+happyReduction_562 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut225 happy_x_2 of { (HappyWrap225 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( fmap ecpFromExp $+                                  ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (DecBrL noExtField (snd happy_var_2)))+                                      (mo happy_var_1:mu AnnCloseQ happy_var_3:fst happy_var_2))}}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_563 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_563 = happySpecReduce_1  203# happyReduction_563+happyReduction_563 happy_x_1+	 =  case happyOut209 happy_x_1 of { (HappyWrap209 happy_var_1) -> +	happyIn219+		 (ECP $ mkHsSplicePV happy_var_1+	)}++happyReduce_564 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_564 = happyMonadReduce 4# 203# happyReduction_564+happyReduction_564 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> +	case happyOut223 happy_x_3 of { (HappyWrap223 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                     fmap ecpFromCmd $+                                     ams (sLL happy_var_1 happy_var_4 $ HsCmdArrForm noExtField happy_var_2 Prefix+                                                          Nothing (reverse happy_var_3))+                                         [mu AnnOpenB happy_var_1,mu AnnCloseB happy_var_4])}}}})+	) (\r -> happyReturn (happyIn219 r))++happyReduce_565 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_565 = happySpecReduce_1  204# happyReduction_565+happyReduction_565 happy_x_1+	 =  case happyOut221 happy_x_1 of { (HappyWrap221 happy_var_1) -> +	happyIn220+		 (mapLoc (HsSpliceE noExtField) happy_var_1+	)}++happyReduce_566 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_566 = happySpecReduce_1  204# happyReduction_566+happyReduction_566 happy_x_1+	 =  case happyOut222 happy_x_1 of { (HappyWrap222 happy_var_1) -> +	happyIn220+		 (mapLoc (HsSpliceE noExtField) happy_var_1+	)}++happyReduce_567 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_567 = happyMonadReduce 2# 205# happyReduction_567+happyReduction_567 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut219 happy_x_2 of { (HappyWrap219 happy_var_2) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                   ams (sLL happy_var_1 happy_var_2 $ mkUntypedSplice DollarSplice happy_var_2)+                                       [mj AnnDollar happy_var_1])}})+	) (\r -> happyReturn (happyIn221 r))++happyReduce_568 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_568 = happyMonadReduce 2# 206# happyReduction_568+happyReduction_568 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut219 happy_x_2 of { (HappyWrap219 happy_var_2) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                   ams (sLL happy_var_1 happy_var_2 $ mkTypedSplice DollarSplice happy_var_2)+                                       [mj AnnDollarDollar happy_var_1])}})+	) (\r -> happyReturn (happyIn222 r))++happyReduce_569 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_569 = happySpecReduce_2  207# happyReduction_569+happyReduction_569 happy_x_2+	happy_x_1+	 =  case happyOut223 happy_x_1 of { (HappyWrap223 happy_var_1) -> +	case happyOut224 happy_x_2 of { (HappyWrap224 happy_var_2) -> +	happyIn223+		 (happy_var_2 : happy_var_1+	)}}++happyReduce_570 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_570 = happySpecReduce_0  207# happyReduction_570+happyReduction_570  =  happyIn223+		 ([]+	)++happyReduce_571 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_571 = happyMonadReduce 1# 208# happyReduction_571+happyReduction_571 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut217 happy_x_1 of { (HappyWrap217 happy_var_1) -> +	( runECP_P happy_var_1 >>= \ cmd ->+                                   runPV (checkCmdBlockArguments cmd) >>= \ _ ->+                                   return (sL1 cmd $ HsCmdTop noExtField cmd))})+	) (\r -> happyReturn (happyIn224 r))++happyReduce_572 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_572 = happySpecReduce_3  209# happyReduction_572+happyReduction_572 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut226 happy_x_2 of { (HappyWrap226 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn225+		 (([mj AnnOpenC happy_var_1+                                                  ,mj AnnCloseC happy_var_3],happy_var_2)+	)}}}++happyReduce_573 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_573 = happySpecReduce_3  209# happyReduction_573+happyReduction_573 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut226 happy_x_2 of { (HappyWrap226 happy_var_2) -> +	happyIn225+		 (([],happy_var_2)+	)}++happyReduce_574 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_574 = happySpecReduce_1  210# happyReduction_574+happyReduction_574 happy_x_1+	 =  case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> +	happyIn226+		 (cvTopDecls happy_var_1+	)}++happyReduce_575 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_575 = happySpecReduce_1  210# happyReduction_575+happyReduction_575 happy_x_1+	 =  case happyOut75 happy_x_1 of { (HappyWrap75 happy_var_1) -> +	happyIn226+		 (cvTopDecls happy_var_1+	)}++happyReduce_576 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_576 = happySpecReduce_1  211# happyReduction_576+happyReduction_576 happy_x_1+	 =  case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> +	happyIn227+		 (happy_var_1+	)}++happyReduce_577 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_577 = happyMonadReduce 2# 211# happyReduction_577+happyReduction_577 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> +	case happyOut293 happy_x_2 of { (HappyWrap293 happy_var_2) -> +	( runECP_P happy_var_1 >>= \ happy_var_1 ->+                                runPV (rejectPragmaPV happy_var_1) >>+                                runPV happy_var_2 >>= \ happy_var_2 ->+                                return $ ecpFromExp $+                                sLL happy_var_1 happy_var_2 $ SectionL noExtField happy_var_1 happy_var_2)}})+	) (\r -> happyReturn (happyIn227 r))++happyReduce_578 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_578 = happySpecReduce_2  211# happyReduction_578+happyReduction_578 happy_x_2+	happy_x_1+	 =  case happyOut294 happy_x_1 of { (HappyWrap294 happy_var_1) -> +	case happyOut211 happy_x_2 of { (HappyWrap211 happy_var_2) -> +	happyIn227+		 (ECP $+                                superInfixOp $+                                runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                happy_var_1 >>= \ happy_var_1 ->+                                mkHsSectionR_PV (comb2 happy_var_1 happy_var_2) happy_var_1 happy_var_2+	)}}++happyReduce_579 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_579 = happySpecReduce_3  211# happyReduction_579+happyReduction_579 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> +	happyIn227+		 (ECP $+                             runECP_PV happy_var_1 >>= \ happy_var_1 ->+                             runECP_PV happy_var_3 >>= \ happy_var_3 ->+                             amms (mkHsViewPatPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_3) [mu AnnRarrow happy_var_2]+	)}}}++happyReduce_580 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_580 = happySpecReduce_2  212# happyReduction_580+happyReduction_580 happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOut229 happy_x_2 of { (HappyWrap229 happy_var_2) -> +	happyIn228+		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->+                             happy_var_2 >>= \ happy_var_2 ->+                             do { addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2)+                                ; return ([],Tuple ((sL1 happy_var_1 (Just happy_var_1)) : snd happy_var_2)) }+	)}}++happyReduce_581 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_581 = happySpecReduce_2  212# happyReduction_581+happyReduction_581 happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOut321 happy_x_2 of { (HappyWrap321 happy_var_2) -> +	happyIn228+		 (runECP_PV happy_var_1 >>= \ happy_var_1 -> return $+                            (mvbars (fst happy_var_2), Sum 1  (snd happy_var_2 + 1) happy_var_1)+	)}}++happyReduce_582 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_582 = happySpecReduce_2  212# happyReduction_582+happyReduction_582 happy_x_2+	happy_x_1+	 =  case happyOut319 happy_x_1 of { (HappyWrap319 happy_var_1) -> +	case happyOut230 happy_x_2 of { (HappyWrap230 happy_var_2) -> +	happyIn228+		 (happy_var_2 >>= \ happy_var_2 ->+                   do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (fst happy_var_1)+                      ; return+                           ([],Tuple (map (\l -> L l Nothing) (fst happy_var_1) ++ happy_var_2)) }+	)}}++happyReduce_583 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_583 = happySpecReduce_3  212# happyReduction_583+happyReduction_583 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> +	case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> +	case happyOut320 happy_x_3 of { (HappyWrap320 happy_var_3) -> +	happyIn228+		 (runECP_PV happy_var_2 >>= \ happy_var_2 -> return $+                  (mvbars (fst happy_var_1) ++ mvbars (fst happy_var_3), Sum (snd happy_var_1 + 1) (snd happy_var_1 + snd happy_var_3 + 1) happy_var_2)+	)}}}++happyReduce_584 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_584 = happySpecReduce_2  213# happyReduction_584+happyReduction_584 happy_x_2+	happy_x_1+	 =  case happyOut319 happy_x_1 of { (HappyWrap319 happy_var_1) -> +	case happyOut230 happy_x_2 of { (HappyWrap230 happy_var_2) -> +	happyIn229+		 (happy_var_2 >>= \ happy_var_2 ->+          do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst happy_var_1)+             ; return (+            (head $ fst happy_var_1+            ,(map (\l -> L l Nothing) (tail $ fst happy_var_1)) ++ happy_var_2)) }+	)}}++happyReduce_585 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_585 = happySpecReduce_2  214# happyReduction_585+happyReduction_585 happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOut229 happy_x_2 of { (HappyWrap229 happy_var_2) -> +	happyIn230+		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                   happy_var_2 >>= \ happy_var_2 ->+                                   addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2) >>+                                   return ((L (gl happy_var_1) (Just happy_var_1)) : snd happy_var_2)+	)}}++happyReduce_586 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_586 = happySpecReduce_1  214# happyReduction_586+happyReduction_586 happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	happyIn230+		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                   return [L (gl happy_var_1) (Just happy_var_1)]+	)}++happyReduce_587 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_587 = happySpecReduce_0  214# happyReduction_587+happyReduction_587  =  happyIn230+		 (return [noLoc Nothing]+	)++happyReduce_588 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_588 = happySpecReduce_1  215# happyReduction_588+happyReduction_588 happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	happyIn231+		 (\loc -> runECP_PV happy_var_1 >>= \ happy_var_1 ->+                            mkHsExplicitListPV loc [happy_var_1]+	)}++happyReduce_589 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_589 = happySpecReduce_1  215# happyReduction_589+happyReduction_589 happy_x_1+	 =  case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> +	happyIn231+		 (\loc -> happy_var_1 >>= \ happy_var_1 ->+                            mkHsExplicitListPV loc (reverse happy_var_1)+	)}++happyReduce_590 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_590 = happySpecReduce_2  215# happyReduction_590+happyReduction_590 happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn231+		 (\loc ->    runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                  ams (L loc $ ArithSeq noExtField Nothing (From happy_var_1))+                                      [mj AnnDotdot happy_var_2]+                                      >>= ecpFromExp'+	)}}++happyReduce_591 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_591 = happyReduce 4# 215# happyReduction_591+happyReduction_591 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	happyIn231+		 (\loc ->+                                   runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                   ams (L loc $ ArithSeq noExtField Nothing (FromThen happy_var_1 happy_var_3))+                                       [mj AnnComma happy_var_2,mj AnnDotdot happy_var_4]+                                       >>= ecpFromExp'+	) `HappyStk` happyRest}}}}++happyReduce_592 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_592 = happySpecReduce_3  215# happyReduction_592+happyReduction_592 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	happyIn231+		 (\loc -> runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                   ams (L loc $ ArithSeq noExtField Nothing (FromTo happy_var_1 happy_var_3))+                                       [mj AnnDotdot happy_var_2]+                                       >>= ecpFromExp'+	)}}}++happyReduce_593 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_593 = happyReduce 5# 215# happyReduction_593+happyReduction_593 (happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	case happyOutTok happy_x_4 of { happy_var_4 -> +	case happyOut210 happy_x_5 of { (HappyWrap210 happy_var_5) -> +	happyIn231+		 (\loc ->+                                   runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                   runECP_PV happy_var_5 >>= \ happy_var_5 ->+                                   ams (L loc $ ArithSeq noExtField Nothing (FromThenTo happy_var_1 happy_var_3 happy_var_5))+                                       [mj AnnComma happy_var_2,mj AnnDotdot happy_var_4]+                                       >>= ecpFromExp'+	) `HappyStk` happyRest}}}}}++happyReduce_594 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_594 = happySpecReduce_3  215# happyReduction_594+happyReduction_594 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut233 happy_x_3 of { (HappyWrap233 happy_var_3) -> +	happyIn231+		 (\loc ->+                checkMonadComp >>= \ ctxt ->+                runECP_PV happy_var_1 >>= \ happy_var_1 ->+                ams (L loc $ mkHsComp ctxt (unLoc happy_var_3) happy_var_1)+                    [mj AnnVbar happy_var_2]+                    >>= ecpFromExp'+	)}}}++happyReduce_595 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_595 = happySpecReduce_3  216# happyReduction_595+happyReduction_595 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> +	happyIn232+		 (happy_var_1 >>= \ happy_var_1 ->+                                     runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                     addAnnotation (gl $ head $ happy_var_1)+                                                            AnnComma (gl happy_var_2) >>+                                      return (((:) $! happy_var_3) $! happy_var_1)+	)}}}++happyReduce_596 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_596 = happySpecReduce_3  216# happyReduction_596+happyReduction_596 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> +	happyIn232+		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                      runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                      addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+                                      return [happy_var_3,happy_var_1]+	)}}}++happyReduce_597 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_597 = happySpecReduce_1  217# happyReduction_597+happyReduction_597 happy_x_1+	 =  case happyOut234 happy_x_1 of { (HappyWrap234 happy_var_1) -> +	happyIn233+		 (case (unLoc happy_var_1) of+                    [qs] -> sL1 happy_var_1 qs+                    -- We just had one thing in our "parallel" list so+                    -- we simply return that thing directly++                    qss -> sL1 happy_var_1 [sL1 happy_var_1 $ ParStmt noExtField [ParStmtBlock noExtField qs [] noSyntaxExpr |+                                            qs <- qss]+                                            noExpr noSyntaxExpr]+                    -- We actually found some actual parallel lists so+                    -- we wrap them into as a ParStmt+	)}++happyReduce_598 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_598 = happyMonadReduce 3# 218# happyReduction_598+happyReduction_598 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut234 happy_x_3 of { (HappyWrap234 happy_var_3) -> +	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_2) >>+                        return (sLL happy_var_1 happy_var_3 (reverse (unLoc happy_var_1) : unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn234 r))++happyReduce_599 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_599 = happySpecReduce_1  218# happyReduction_599+happyReduction_599 happy_x_1+	 =  case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> +	happyIn234+		 (L (getLoc happy_var_1) [reverse (unLoc happy_var_1)]+	)}++happyReduce_600 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_600 = happyMonadReduce 3# 219# happyReduction_600+happyReduction_600 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut236 happy_x_3 of { (HappyWrap236 happy_var_3) -> +	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+                amsL (comb2 happy_var_1 happy_var_3) (fst $ unLoc happy_var_3) >>+                return (sLL happy_var_1 happy_var_3 [sLL happy_var_1 happy_var_3 ((snd $ unLoc happy_var_3) (reverse (unLoc happy_var_1)))]))}}})+	) (\r -> happyReturn (happyIn235 r))++happyReduce_601 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_601 = happyMonadReduce 3# 219# happyReduction_601+happyReduction_601 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut257 happy_x_3 of { (HappyWrap257 happy_var_3) -> +	( runPV happy_var_3 >>= \ happy_var_3 ->+                addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>+                return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+	) (\r -> happyReturn (happyIn235 r))++happyReduce_602 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_602 = happyMonadReduce 1# 219# happyReduction_602+happyReduction_602 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut236 happy_x_1 of { (HappyWrap236 happy_var_1) -> +	( ams happy_var_1 (fst $ unLoc happy_var_1) >>+                              return (sLL happy_var_1 happy_var_1 [L (getLoc happy_var_1) ((snd $ unLoc happy_var_1) [])]))})+	) (\r -> happyReturn (happyIn235 r))++happyReduce_603 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_603 = happyMonadReduce 1# 219# happyReduction_603+happyReduction_603 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> +	( runPV happy_var_1 >>= \ happy_var_1 ->+                                            return $ sL1 happy_var_1 [happy_var_1])})+	) (\r -> happyReturn (happyIn235 r))++happyReduce_604 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_604 = happyMonadReduce 2# 220# happyReduction_604+happyReduction_604 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 -> return $+                                 sLL happy_var_1 happy_var_2 ([mj AnnThen happy_var_1], \ss -> (mkTransformStmt ss happy_var_2)))}})+	) (\r -> happyReturn (happyIn236 r))++happyReduce_605 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_605 = happyMonadReduce 4# 220# happyReduction_605+happyReduction_605 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+                                 runECP_P happy_var_4 >>= \ happy_var_4 ->+                                 return $ sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnBy  happy_var_3],+                                                     \ss -> (mkTransformByStmt ss happy_var_2 happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn236 r))++happyReduce_606 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_606 = happyMonadReduce 4# 220# happyReduction_606+happyReduction_606 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	( runECP_P happy_var_4 >>= \ happy_var_4 ->+               return $ sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnUsing happy_var_3],+                                   \ss -> (mkGroupUsingStmt ss happy_var_4)))}}}})+	) (\r -> happyReturn (happyIn236 r))++happyReduce_607 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_607 = happyMonadReduce 6# 220# happyReduction_607+happyReduction_607 (happy_x_6 `HappyStk`+	happy_x_5 `HappyStk`+	happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	case happyOutTok happy_x_5 of { happy_var_5 -> +	case happyOut210 happy_x_6 of { (HappyWrap210 happy_var_6) -> +	( runECP_P happy_var_4 >>= \ happy_var_4 ->+               runECP_P happy_var_6 >>= \ happy_var_6 ->+               return $ sLL happy_var_1 happy_var_6 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnBy happy_var_3,mj AnnUsing happy_var_5],+                                   \ss -> (mkGroupByUsingStmt ss happy_var_4 happy_var_6)))}}}}}})+	) (\r -> happyReturn (happyIn236 r))++happyReduce_608 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_608 = happySpecReduce_1  221# happyReduction_608+happyReduction_608 happy_x_1+	 =  case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> +	happyIn237+		 (L (getLoc happy_var_1) (reverse (unLoc happy_var_1))+	)}++happyReduce_609 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_609 = happyMonadReduce 3# 222# happyReduction_609+happyReduction_609 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut257 happy_x_3 of { (HappyWrap257 happy_var_3) -> +	( runPV happy_var_3 >>= \ happy_var_3 ->+                               addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma+                                             (gl happy_var_2) >>+                               return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})+	) (\r -> happyReturn (happyIn238 r))++happyReduce_610 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_610 = happyMonadReduce 1# 222# happyReduction_610+happyReduction_610 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> +	( runPV happy_var_1 >>= \ happy_var_1 ->+                               return $ sL1 happy_var_1 [happy_var_1])})+	) (\r -> happyReturn (happyIn238 r))++happyReduce_611 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_611 = happySpecReduce_3  223# happyReduction_611+happyReduction_611 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn239+		 (happy_var_2 >>= \ happy_var_2 -> return $+                                     sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))+                                               ,(reverse (snd $ unLoc happy_var_2)))+	)}}}++happyReduce_612 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_612 = happySpecReduce_3  223# happyReduction_612+happyReduction_612 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> +	happyIn239+		 (happy_var_2 >>= \ happy_var_2 -> return $+                                       L (getLoc happy_var_2) (fst $ unLoc happy_var_2+                                        ,(reverse (snd $ unLoc happy_var_2)))+	)}++happyReduce_613 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_613 = happySpecReduce_2  223# happyReduction_613+happyReduction_613 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn239+		 (return $ sLL happy_var_1 happy_var_2 ([moc happy_var_1,mcc happy_var_2],[])+	)}}++happyReduce_614 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_614 = happySpecReduce_2  223# happyReduction_614+happyReduction_614 happy_x_2+	happy_x_1+	 =  happyIn239+		 (return $ noLoc ([],[])+	)++happyReduce_615 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_615 = happySpecReduce_1  224# happyReduction_615+happyReduction_615 happy_x_1+	 =  case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> +	happyIn240+		 (happy_var_1 >>= \ happy_var_1 -> return $+                                     sL1 happy_var_1 (fst $ unLoc happy_var_1,snd $ unLoc happy_var_1)+	)}++happyReduce_616 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_616 = happySpecReduce_2  224# happyReduction_616+happyReduction_616 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> +	happyIn240+		 (happy_var_2 >>= \ happy_var_2 -> return $+                                     sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_1:(fst $ unLoc happy_var_2))+                                               ,snd $ unLoc happy_var_2)+	)}}++happyReduce_617 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_617 = happySpecReduce_3  225# happyReduction_617+happyReduction_617 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut242 happy_x_3 of { (HappyWrap242 happy_var_3) -> +	happyIn241+		 (happy_var_1 >>= \ happy_var_1 ->+                                  happy_var_3 >>= \ happy_var_3 ->+                                     if null (snd $ unLoc happy_var_1)+                                     then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                  ,[happy_var_3]))+                                     else (ams (head $ snd $ unLoc happy_var_1)+                                               (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))+                                           >> return (sLL happy_var_1 happy_var_3 ([],happy_var_3 : (snd $ unLoc happy_var_1))) )+	)}}}++happyReduce_618 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_618 = happySpecReduce_2  225# happyReduction_618+happyReduction_618 happy_x_2+	happy_x_1+	 =  case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn241+		 (happy_var_1 >>= \ happy_var_1 ->+                                   if null (snd $ unLoc happy_var_1)+                                     then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                  ,snd $ unLoc happy_var_1))+                                     else (ams (head $ snd $ unLoc happy_var_1)+                                               (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))+                                           >> return (sLL happy_var_1 happy_var_2 ([],snd $ unLoc happy_var_1)))+	)}}++happyReduce_619 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_619 = happySpecReduce_1  225# happyReduction_619+happyReduction_619 happy_x_1+	 =  case happyOut242 happy_x_1 of { (HappyWrap242 happy_var_1) -> +	happyIn241+		 (happy_var_1 >>= \ happy_var_1 -> return $ sL1 happy_var_1 ([],[happy_var_1])+	)}++happyReduce_620 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_620 = happySpecReduce_2  226# happyReduction_620+happyReduction_620 happy_x_2+	happy_x_1+	 =  case happyOut248 happy_x_1 of { (HappyWrap248 happy_var_1) -> +	case happyOut243 happy_x_2 of { (HappyWrap243 happy_var_2) -> +	happyIn242+		 (happy_var_2 >>= \ happy_var_2 ->+                            ams (sLL happy_var_1 happy_var_2 (Match { m_ext = noExtField+                                                  , m_ctxt = CaseAlt+                                                  , m_pats = [happy_var_1]+                                                  , m_grhss = snd $ unLoc happy_var_2 }))+                                      (fst $ unLoc happy_var_2)+	)}}++happyReduce_621 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_621 = happySpecReduce_2  227# happyReduction_621+happyReduction_621 happy_x_2+	happy_x_1+	 =  case happyOut244 happy_x_1 of { (HappyWrap244 happy_var_1) -> +	case happyOut128 happy_x_2 of { (HappyWrap128 happy_var_2) -> +	happyIn243+		 (happy_var_1 >>= \alt ->+                                      return $ sLL alt happy_var_2 (fst $ unLoc happy_var_2, GRHSs noExtField (unLoc alt) (snd $ unLoc happy_var_2))+	)}}++happyReduce_622 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_622 = happySpecReduce_2  228# happyReduction_622+happyReduction_622 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	happyIn244+		 (runECP_PV happy_var_2 >>= \ happy_var_2 ->+                                ams (sLL happy_var_1 happy_var_2 (unguardedRHS (comb2 happy_var_1 happy_var_2) happy_var_2))+                                    [mu AnnRarrow happy_var_1]+	)}}++happyReduce_623 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_623 = happySpecReduce_1  228# happyReduction_623+happyReduction_623 happy_x_1+	 =  case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> +	happyIn244+		 (happy_var_1 >>= \gdpats ->+                                return $ sL1 gdpats (reverse (unLoc gdpats))+	)}++happyReduce_624 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_624 = happySpecReduce_2  229# happyReduction_624+happyReduction_624 happy_x_2+	happy_x_1+	 =  case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> +	case happyOut247 happy_x_2 of { (HappyWrap247 happy_var_2) -> +	happyIn245+		 (happy_var_1 >>= \gdpats ->+                         happy_var_2 >>= \gdpat ->+                         return $ sLL gdpats gdpat (gdpat : unLoc gdpats)+	)}}++happyReduce_625 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_625 = happySpecReduce_1  229# happyReduction_625+happyReduction_625 happy_x_1+	 =  case happyOut247 happy_x_1 of { (HappyWrap247 happy_var_1) -> +	happyIn245+		 (happy_var_1 >>= \gdpat -> return $ sL1 gdpat [gdpat]+	)}++happyReduce_626 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_626 = happyMonadReduce 3# 230# happyReduction_626+happyReduction_626 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut245 happy_x_2 of { (HappyWrap245 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( runPV happy_var_2 >>= \ happy_var_2 ->+                                             return $ sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3],unLoc happy_var_2))}}})+	) (\r -> happyReturn (happyIn246 r))++happyReduce_627 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_627 = happyMonadReduce 2# 230# happyReduction_627+happyReduction_627 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> +	( runPV happy_var_1 >>= \ happy_var_1 ->+                                             return $ sL1 happy_var_1 ([],unLoc happy_var_1))})+	) (\r -> happyReturn (happyIn246 r))++happyReduce_628 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_628 = happyReduce 4# 231# happyReduction_628+happyReduction_628 (happy_x_4 `HappyStk`+	happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest)+	 = case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> +	happyIn247+		 (runECP_PV happy_var_4 >>= \ happy_var_4 ->+                                     ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS noExtField (unLoc happy_var_2) happy_var_4)+                                         [mj AnnVbar happy_var_1,mu AnnRarrow happy_var_3]+	) `HappyStk` happyRest}}}}++happyReduce_629 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_629 = happyMonadReduce 1# 232# happyReduction_629+happyReduction_629 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> +	( (checkPattern <=< runECP_P) happy_var_1)})+	) (\r -> happyReturn (happyIn248 r))++happyReduce_630 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_630 = happyMonadReduce 1# 233# happyReduction_630+happyReduction_630 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> +	( -- See Note [Parser-Validator ReaderT SDoc] in GHC.Parser.PostProcess+                             checkPattern_msg (text "Possibly caused by a missing 'do'?")+                                              (runECP_PV happy_var_1))})+	) (\r -> happyReturn (happyIn249 r))++happyReduce_631 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_631 = happyMonadReduce 1# 234# happyReduction_631+happyReduction_631 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut217 happy_x_1 of { (HappyWrap217 happy_var_1) -> +	( (checkPattern <=< runECP_P) happy_var_1)})+	) (\r -> happyReturn (happyIn250 r))++happyReduce_632 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_632 = happySpecReduce_2  235# happyReduction_632+happyReduction_632 happy_x_2+	happy_x_1+	 =  case happyOut250 happy_x_1 of { (HappyWrap250 happy_var_1) -> +	case happyOut251 happy_x_2 of { (HappyWrap251 happy_var_2) -> +	happyIn251+		 (happy_var_1 : happy_var_2+	)}}++happyReduce_633 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_633 = happySpecReduce_0  235# happyReduction_633+happyReduction_633  =  happyIn251+		 ([]+	)++happyReduce_634 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_634 = happySpecReduce_3  236# happyReduction_634+happyReduction_634 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut253 happy_x_2 of { (HappyWrap253 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn252+		 (happy_var_2 >>= \ happy_var_2 -> return $+                                          sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))+                                             ,(reverse $ snd $ unLoc happy_var_2))+	)}}}++happyReduce_635 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_635 = happySpecReduce_3  236# happyReduction_635+happyReduction_635 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut253 happy_x_2 of { (HappyWrap253 happy_var_2) -> +	happyIn252+		 (happy_var_2 >>= \ happy_var_2 -> return $+                                          L (gl happy_var_2) (fst $ unLoc happy_var_2+                                                    ,reverse $ snd $ unLoc happy_var_2)+	)}++happyReduce_636 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_636 = happySpecReduce_3  237# happyReduction_636+happyReduction_636 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut256 happy_x_3 of { (HappyWrap256 happy_var_3) -> +	happyIn253+		 (happy_var_1 >>= \ happy_var_1 ->+                            happy_var_3 >>= \ happy_var_3 ->+                            if null (snd $ unLoc happy_var_1)+                              then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)+                                                     ,happy_var_3 : (snd $ unLoc happy_var_1)))+                              else do+                               { ams (head $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]+                               ; return $ sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,happy_var_3 :(snd $ unLoc happy_var_1)) }+	)}}}++happyReduce_637 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_637 = happySpecReduce_2  237# happyReduction_637+happyReduction_637 happy_x_2+	happy_x_1+	 =  case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn253+		 (happy_var_1 >>= \ happy_var_1 ->+                           if null (snd $ unLoc happy_var_1)+                             then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1),snd $ unLoc happy_var_1))+                             else do+                               { ams (head $ snd $ unLoc happy_var_1)+                                               [mj AnnSemi happy_var_2]+                               ; return happy_var_1 }+	)}}++happyReduce_638 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_638 = happySpecReduce_1  237# happyReduction_638+happyReduction_638 happy_x_1+	 =  case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> +	happyIn253+		 (happy_var_1 >>= \ happy_var_1 ->+                                   return $ sL1 happy_var_1 ([],[happy_var_1])+	)}++happyReduce_639 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_639 = happySpecReduce_0  237# happyReduction_639+happyReduction_639  =  happyIn253+		 (return $ noLoc ([],[])+	)++happyReduce_640 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_640 = happyMonadReduce 1# 238# happyReduction_640+happyReduction_640 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> +	( fmap Just (runPV happy_var_1))})+	) (\r -> happyReturn (happyIn254 r))++happyReduce_641 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_641 = happySpecReduce_0  238# happyReduction_641+happyReduction_641  =  happyIn254+		 (Nothing+	)++happyReduce_642 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_642 = happyMonadReduce 1# 239# happyReduction_642+happyReduction_642 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> +	( runPV happy_var_1)})+	) (\r -> happyReturn (happyIn255 r))++happyReduce_643 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_643 = happySpecReduce_1  240# happyReduction_643+happyReduction_643 happy_x_1+	 =  case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> +	happyIn256+		 (happy_var_1+	)}++happyReduce_644 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_644 = happySpecReduce_2  240# happyReduction_644+happyReduction_644 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut252 happy_x_2 of { (HappyWrap252 happy_var_2) -> +	happyIn256+		 (happy_var_2 >>= \ happy_var_2 ->+                                           ams (sLL happy_var_1 happy_var_2 $ mkRecStmt (snd $ unLoc happy_var_2))+                                               (mj AnnRec happy_var_1:(fst $ unLoc happy_var_2))+	)}}++happyReduce_645 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_645 = happySpecReduce_3  241# happyReduction_645+happyReduction_645 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut249 happy_x_1 of { (HappyWrap249 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	happyIn257+		 (runECP_PV happy_var_3 >>= \ happy_var_3 ->+                                           ams (sLL happy_var_1 happy_var_3 $ mkPsBindStmt happy_var_1 happy_var_3)+                                               [mu AnnLarrow happy_var_2]+	)}}}++happyReduce_646 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_646 = happySpecReduce_1  241# happyReduction_646+happyReduction_646 happy_x_1+	 =  case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> +	happyIn257+		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->+                                           return $ sL1 happy_var_1 $ mkBodyStmt happy_var_1+	)}++happyReduce_647 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_647 = happySpecReduce_2  241# happyReduction_647+happyReduction_647 happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> +	happyIn257+		 (ams (sLL happy_var_1 happy_var_2 $ LetStmt noExtField (snd $ unLoc happy_var_2))+                                               (mj AnnLet happy_var_1:(fst $ unLoc happy_var_2))+	)}}++happyReduce_648 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_648 = happySpecReduce_1  242# happyReduction_648+happyReduction_648 happy_x_1+	 =  case happyOut259 happy_x_1 of { (HappyWrap259 happy_var_1) -> +	happyIn258+		 (happy_var_1+	)}++happyReduce_649 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_649 = happySpecReduce_0  242# happyReduction_649+happyReduction_649  =  happyIn258+		 (return ([],([], Nothing))+	)++happyReduce_650 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_650 = happySpecReduce_3  243# happyReduction_650+happyReduction_650 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut260 happy_x_1 of { (HappyWrap260 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut259 happy_x_3 of { (HappyWrap259 happy_var_3) -> +	happyIn259+		 (happy_var_1 >>= \ happy_var_1 ->+                   happy_var_3 >>= \ happy_var_3 ->+                   addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+                   return (case happy_var_3 of (ma,(flds, dd)) -> (ma,(happy_var_1 : flds, dd)))+	)}}}++happyReduce_651 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_651 = happySpecReduce_1  243# happyReduction_651+happyReduction_651 happy_x_1+	 =  case happyOut260 happy_x_1 of { (HappyWrap260 happy_var_1) -> +	happyIn259+		 (happy_var_1 >>= \ happy_var_1 ->+                                          return ([],([happy_var_1], Nothing))+	)}++happyReduce_652 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_652 = happySpecReduce_1  243# happyReduction_652+happyReduction_652 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn259+		 (return ([mj AnnDotdot happy_var_1],([],   Just (getLoc happy_var_1)))+	)}++happyReduce_653 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_653 = happySpecReduce_3  244# happyReduction_653+happyReduction_653 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> +	happyIn260+		 (runECP_PV happy_var_3 >>= \ happy_var_3 ->+                           ams  (sLL happy_var_1 happy_var_3 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) happy_var_3 False)+                                [mj AnnEqual happy_var_2]+	)}}}++happyReduce_654 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_654 = happySpecReduce_1  244# happyReduction_654+happyReduction_654 happy_x_1+	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> +	happyIn260+		 (placeHolderPunRhs >>= \rhs ->+                          return $ sLL happy_var_1 happy_var_1 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) rhs True+	)}++happyReduce_655 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_655 = happyMonadReduce 3# 245# happyReduction_655+happyReduction_655 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut262 happy_x_3 of { (HappyWrap262 happy_var_3) -> +	( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>+                         return (let { this = happy_var_3; rest = unLoc happy_var_1 }+                              in rest `seq` this `seq` sLL happy_var_1 happy_var_3 (this : rest)))}}})+	) (\r -> happyReturn (happyIn261 r))++happyReduce_656 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_656 = happyMonadReduce 2# 245# happyReduction_656+happyReduction_656 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>+                         return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})+	) (\r -> happyReturn (happyIn261 r))++happyReduce_657 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_657 = happySpecReduce_1  245# happyReduction_657+happyReduction_657 happy_x_1+	 =  case happyOut262 happy_x_1 of { (HappyWrap262 happy_var_1) -> +	happyIn261+		 (let this = happy_var_1 in this `seq` sL1 happy_var_1 [this]+	)}++happyReduce_658 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_658 = happyMonadReduce 3# 246# happyReduction_658+happyReduction_658 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> +	( runECP_P happy_var_3 >>= \ happy_var_3 ->+                                          ams (sLL happy_var_1 happy_var_3 (IPBind noExtField (Left happy_var_1) happy_var_3))+                                              [mj AnnEqual happy_var_2])}}})+	) (\r -> happyReturn (happyIn262 r))++happyReduce_659 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_659 = happySpecReduce_1  247# happyReduction_659+happyReduction_659 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn263+		 (sL1 happy_var_1 (HsIPName (getIPDUPVARID happy_var_1))+	)}++happyReduce_660 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_660 = happySpecReduce_1  248# happyReduction_660+happyReduction_660 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn264+		 (sL1 happy_var_1 (getLABELVARID happy_var_1)+	)}++happyReduce_661 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_661 = happySpecReduce_1  249# happyReduction_661+happyReduction_661 happy_x_1+	 =  case happyOut266 happy_x_1 of { (HappyWrap266 happy_var_1) -> +	happyIn265+		 (happy_var_1+	)}++happyReduce_662 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_662 = happySpecReduce_0  249# happyReduction_662+happyReduction_662  =  happyIn265+		 (noLoc mkTrue+	)++happyReduce_663 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_663 = happySpecReduce_1  250# happyReduction_663+happyReduction_663 happy_x_1+	 =  case happyOut267 happy_x_1 of { (HappyWrap267 happy_var_1) -> +	happyIn266+		 (happy_var_1+	)}++happyReduce_664 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_664 = happyMonadReduce 3# 250# happyReduction_664+happyReduction_664 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut267 happy_x_1 of { (HappyWrap267 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut266 happy_x_3 of { (HappyWrap266 happy_var_3) -> +	( aa happy_var_1 (AnnVbar, happy_var_2)+                              >> return (sLL happy_var_1 happy_var_3 (Or [happy_var_1,happy_var_3])))}}})+	) (\r -> happyReturn (happyIn266 r))++happyReduce_665 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_665 = happySpecReduce_1  251# happyReduction_665+happyReduction_665 happy_x_1+	 =  case happyOut268 happy_x_1 of { (HappyWrap268 happy_var_1) -> +	happyIn267+		 (sLL (head happy_var_1) (last happy_var_1) (And (happy_var_1))+	)}++happyReduce_666 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_666 = happySpecReduce_1  252# happyReduction_666+happyReduction_666 happy_x_1+	 =  case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> +	happyIn268+		 ([happy_var_1]+	)}++happyReduce_667 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_667 = happyMonadReduce 3# 252# happyReduction_667+happyReduction_667 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut268 happy_x_3 of { (HappyWrap268 happy_var_3) -> +	( aa happy_var_1 (AnnComma, happy_var_2) >> return (happy_var_1 : happy_var_3))}}})+	) (\r -> happyReturn (happyIn268 r))++happyReduce_668 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_668 = happyMonadReduce 3# 253# happyReduction_668+happyReduction_668 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut266 happy_x_2 of { (HappyWrap266 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (Parens happy_var_2)) [mop happy_var_1,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn269 r))++happyReduce_669 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_669 = happySpecReduce_1  253# happyReduction_669+happyReduction_669 happy_x_1+	 =  case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> +	happyIn269+		 (sL1 happy_var_1 (Var happy_var_1)+	)}++happyReduce_670 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_670 = happySpecReduce_1  254# happyReduction_670+happyReduction_670 happy_x_1+	 =  case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> +	happyIn270+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_671 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_671 = happyMonadReduce 3# 254# happyReduction_671+happyReduction_671 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut270 happy_x_3 of { (HappyWrap270 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+                                    return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn270 r))++happyReduce_672 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_672 = happySpecReduce_1  255# happyReduction_672+happyReduction_672 happy_x_1+	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> +	happyIn271+		 (happy_var_1+	)}++happyReduce_673 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_673 = happySpecReduce_1  255# happyReduction_673+happyReduction_673 happy_x_1+	 =  case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> +	happyIn271+		 (happy_var_1+	)}++happyReduce_674 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_674 = happySpecReduce_1  256# happyReduction_674+happyReduction_674 happy_x_1+	 =  case happyOut274 happy_x_1 of { (HappyWrap274 happy_var_1) -> +	happyIn272+		 (happy_var_1+	)}++happyReduce_675 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_675 = happySpecReduce_1  256# happyReduction_675+happyReduction_675 happy_x_1+	 =  case happyOut277 happy_x_1 of { (HappyWrap277 happy_var_1) -> +	happyIn272+		 (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))+	)}++happyReduce_676 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_676 = happySpecReduce_1  257# happyReduction_676+happyReduction_676 happy_x_1+	 =  case happyOut274 happy_x_1 of { (HappyWrap274 happy_var_1) -> +	happyIn273+		 (happy_var_1+	)}++happyReduce_677 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_677 = happySpecReduce_1  257# happyReduction_677+happyReduction_677 happy_x_1+	 =  case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> +	happyIn273+		 (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))+	)}++happyReduce_678 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_678 = happySpecReduce_1  258# happyReduction_678+happyReduction_678 happy_x_1+	 =  case happyOut312 happy_x_1 of { (HappyWrap312 happy_var_1) -> +	happyIn274+		 (happy_var_1+	)}++happyReduce_679 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_679 = happyMonadReduce 3# 258# happyReduction_679+happyReduction_679 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut314 happy_x_2 of { (HappyWrap314 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                   [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn274 r))++happyReduce_680 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_680 = happySpecReduce_1  259# happyReduction_680+happyReduction_680 happy_x_1+	 =  case happyOut313 happy_x_1 of { (HappyWrap313 happy_var_1) -> +	happyIn275+		 (happy_var_1+	)}++happyReduce_681 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_681 = happyMonadReduce 3# 259# happyReduction_681+happyReduction_681 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut315 happy_x_2 of { (HappyWrap315 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn275 r))++happyReduce_682 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_682 = happySpecReduce_1  259# happyReduction_682+happyReduction_682 happy_x_1+	 =  case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> +	happyIn275+		 (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))+	)}++happyReduce_683 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_683 = happySpecReduce_1  260# happyReduction_683+happyReduction_683 happy_x_1+	 =  case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> +	happyIn276+		 (sL1 happy_var_1 [happy_var_1]+	)}++happyReduce_684 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_684 = happyMonadReduce 3# 260# happyReduction_684+happyReduction_684 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOut276 happy_x_3 of { (HappyWrap276 happy_var_3) -> +	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>+                                   return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})+	) (\r -> happyReturn (happyIn276 r))++happyReduce_685 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_685 = happyMonadReduce 2# 261# happyReduction_685+happyReduction_685 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 unitDataCon) [mop happy_var_1,mcp happy_var_2])}})+	) (\r -> happyReturn (happyIn277 r))++happyReduce_686 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_686 = happyMonadReduce 3# 261# happyReduction_686+happyReduction_686 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Boxed (snd happy_var_2 + 1))+                                       (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})+	) (\r -> happyReturn (happyIn277 r))++happyReduce_687 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_687 = happyMonadReduce 2# 261# happyReduction_687+happyReduction_687 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 $ unboxedUnitDataCon) [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn277 r))++happyReduce_688 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_688 = happyMonadReduce 3# 261# happyReduction_688+happyReduction_688 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Unboxed (snd happy_var_2 + 1))+                                       (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})+	) (\r -> happyReturn (happyIn277 r))++happyReduce_689 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_689 = happySpecReduce_1  262# happyReduction_689+happyReduction_689 happy_x_1+	 =  case happyOut277 happy_x_1 of { (HappyWrap277 happy_var_1) -> +	happyIn278+		 (happy_var_1+	)}++happyReduce_690 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_690 = happyMonadReduce 2# 262# happyReduction_690+happyReduction_690 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 nilDataCon) [mos happy_var_1,mcs happy_var_2])}})+	) (\r -> happyReturn (happyIn278 r))++happyReduce_691 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_691 = happySpecReduce_1  263# happyReduction_691+happyReduction_691 happy_x_1+	 =  case happyOut315 happy_x_1 of { (HappyWrap315 happy_var_1) -> +	happyIn279+		 (happy_var_1+	)}++happyReduce_692 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_692 = happyMonadReduce 3# 263# happyReduction_692+happyReduction_692 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut313 happy_x_2 of { (HappyWrap313 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn279 r))++happyReduce_693 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_693 = happySpecReduce_1  264# happyReduction_693+happyReduction_693 happy_x_1+	 =  case happyOut314 happy_x_1 of { (HappyWrap314 happy_var_1) -> +	happyIn280+		 (happy_var_1+	)}++happyReduce_694 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_694 = happyMonadReduce 3# 264# happyReduction_694+happyReduction_694 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut312 happy_x_2 of { (HappyWrap312 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn280 r))++happyReduce_695 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_695 = happySpecReduce_1  265# happyReduction_695+happyReduction_695 happy_x_1+	 =  case happyOut282 happy_x_1 of { (HappyWrap282 happy_var_1) -> +	happyIn281+		 (happy_var_1+	)}++happyReduce_696 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_696 = happyMonadReduce 2# 265# happyReduction_696+happyReduction_696 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 $ getRdrName unitTyCon)+                                              [mop happy_var_1,mcp happy_var_2])}})+	) (\r -> happyReturn (happyIn281 r))++happyReduce_697 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_697 = happyMonadReduce 2# 265# happyReduction_697+happyReduction_697 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 $ getRdrName unboxedUnitTyCon)+                                              [mo happy_var_1,mc happy_var_2])}})+	) (\r -> happyReturn (happyIn281 r))++happyReduce_698 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_698 = happySpecReduce_1  266# happyReduction_698+happyReduction_698 happy_x_1+	 =  case happyOut283 happy_x_1 of { (HappyWrap283 happy_var_1) -> +	happyIn282+		 (happy_var_1+	)}++happyReduce_699 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_699 = happyMonadReduce 3# 266# happyReduction_699+happyReduction_699 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Boxed+                                                        (snd happy_var_2 + 1)))+                                       (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})+	) (\r -> happyReturn (happyIn282 r))++happyReduce_700 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_700 = happyMonadReduce 3# 266# happyReduction_700+happyReduction_700 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Unboxed+                                                        (snd happy_var_2 + 1)))+                                       (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})+	) (\r -> happyReturn (happyIn282 r))++happyReduce_701 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_701 = happyMonadReduce 3# 266# happyReduction_701+happyReduction_701 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)+                                       [mop happy_var_1,mu AnnRarrow happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn282 r))++happyReduce_702 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_702 = happyMonadReduce 2# 266# happyReduction_702+happyReduction_702 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	( ams (sLL happy_var_1 happy_var_2 $ listTyCon_RDR) [mos happy_var_1,mcs happy_var_2])}})+	) (\r -> happyReturn (happyIn282 r))++happyReduce_703 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_703 = happySpecReduce_1  267# happyReduction_703+happyReduction_703 happy_x_1+	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> +	happyIn283+		 (happy_var_1+	)}++happyReduce_704 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_704 = happyMonadReduce 3# 267# happyReduction_704+happyReduction_704 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut289 happy_x_2 of { (HappyWrap289 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                               [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn283 r))++happyReduce_705 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_705 = happySpecReduce_1  268# happyReduction_705+happyReduction_705 happy_x_1+	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> +	happyIn284+		 (happy_var_1+	)}++happyReduce_706 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_706 = happyMonadReduce 3# 268# happyReduction_706+happyReduction_706 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( let { name :: Located RdrName+                                    ; name = sL1 happy_var_2 $! mkQual tcClsName (getQCONSYM happy_var_2) }+                                in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn284 r))++happyReduce_707 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_707 = happyMonadReduce 3# 268# happyReduction_707+happyReduction_707 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( let { name :: Located RdrName+                                    ; name = sL1 happy_var_2 $! mkUnqual tcClsName (getCONSYM happy_var_2) }+                                in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn284 r))++happyReduce_708 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_708 = happyMonadReduce 3# 268# happyReduction_708+happyReduction_708 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( let { name :: Located RdrName+                                    ; name = sL1 happy_var_2 $! consDataCon_RDR }+                                in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn284 r))++happyReduce_709 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_709 = happySpecReduce_1  269# happyReduction_709+happyReduction_709 happy_x_1+	 =  case happyOut289 happy_x_1 of { (HappyWrap289 happy_var_1) -> +	happyIn285+		 (happy_var_1+	)}++happyReduce_710 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_710 = happyMonadReduce 3# 269# happyReduction_710+happyReduction_710 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut286 happy_x_2 of { (HappyWrap286 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                               [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                               ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn285 r))++happyReduce_711 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_711 = happySpecReduce_1  270# happyReduction_711+happyReduction_711 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn286+		 (sL1 happy_var_1 $! mkQual tcClsName (getQCONID happy_var_1)+	)}++happyReduce_712 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_712 = happySpecReduce_1  270# happyReduction_712+happyReduction_712 happy_x_1+	 =  case happyOut288 happy_x_1 of { (HappyWrap288 happy_var_1) -> +	happyIn286+		 (happy_var_1+	)}++happyReduce_713 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_713 = happySpecReduce_1  271# happyReduction_713+happyReduction_713 happy_x_1+	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> +	happyIn287+		 (sL1 happy_var_1                           (HsTyVar noExtField NotPromoted happy_var_1)+	)}++happyReduce_714 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_714 = happySpecReduce_2  271# happyReduction_714+happyReduction_714 happy_x_2+	happy_x_1+	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> +	case happyOut323 happy_x_2 of { (HappyWrap323 happy_var_2) -> +	happyIn287+		 (sLL happy_var_1 happy_var_2 (HsDocTy noExtField (sL1 happy_var_1 (HsTyVar noExtField NotPromoted happy_var_1)) happy_var_2)+	)}}++happyReduce_715 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_715 = happySpecReduce_1  272# happyReduction_715+happyReduction_715 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn288+		 (sL1 happy_var_1 $! mkUnqual tcClsName (getCONID happy_var_1)+	)}++happyReduce_716 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_716 = happySpecReduce_1  273# happyReduction_716+happyReduction_716 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn289+		 (sL1 happy_var_1 $! mkQual tcClsName (getQCONSYM happy_var_1)+	)}++happyReduce_717 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_717 = happySpecReduce_1  273# happyReduction_717+happyReduction_717 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn289+		 (sL1 happy_var_1 $! mkQual tcClsName (getQVARSYM happy_var_1)+	)}++happyReduce_718 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_718 = happySpecReduce_1  273# happyReduction_718+happyReduction_718 happy_x_1+	 =  case happyOut290 happy_x_1 of { (HappyWrap290 happy_var_1) -> +	happyIn289+		 (happy_var_1+	)}++happyReduce_719 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_719 = happySpecReduce_1  274# happyReduction_719+happyReduction_719 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn290+		 (sL1 happy_var_1 $! mkUnqual tcClsName (getCONSYM happy_var_1)+	)}++happyReduce_720 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_720 = happySpecReduce_1  274# happyReduction_720+happyReduction_720 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn290+		 (sL1 happy_var_1 $!+                                    -- See Note [eqTyCon (~) is built-in syntax] in GHC.Builtin.Types+                                    if getVARSYM happy_var_1 == fsLit "~"+                                      then eqTyCon_RDR+                                      else mkUnqual tcClsName (getVARSYM happy_var_1)+	)}++happyReduce_721 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_721 = happySpecReduce_1  274# happyReduction_721+happyReduction_721 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn290+		 (sL1 happy_var_1 $! consDataCon_RDR+	)}++happyReduce_722 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_722 = happySpecReduce_1  274# happyReduction_722+happyReduction_722 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn290+		 (sL1 happy_var_1 $! mkUnqual tcClsName (fsLit "-")+	)}++happyReduce_723 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_723 = happySpecReduce_1  274# happyReduction_723+happyReduction_723 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn290+		 (sL1 happy_var_1 $! mkUnqual tcClsName (fsLit ".")+	)}++happyReduce_724 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_724 = happySpecReduce_1  275# happyReduction_724+happyReduction_724 happy_x_1+	 =  case happyOut292 happy_x_1 of { (HappyWrap292 happy_var_1) -> +	happyIn291+		 (happy_var_1+	)}++happyReduce_725 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_725 = happySpecReduce_1  275# happyReduction_725+happyReduction_725 happy_x_1+	 =  case happyOut279 happy_x_1 of { (HappyWrap279 happy_var_1) -> +	happyIn291+		 (happy_var_1+	)}++happyReduce_726 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_726 = happySpecReduce_1  275# happyReduction_726+happyReduction_726 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn291+		 (sL1 happy_var_1 $ getRdrName funTyCon+	)}++happyReduce_727 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_727 = happySpecReduce_1  276# happyReduction_727+happyReduction_727 happy_x_1+	 =  case happyOut308 happy_x_1 of { (HappyWrap308 happy_var_1) -> +	happyIn292+		 (happy_var_1+	)}++happyReduce_728 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_728 = happyMonadReduce 3# 276# happyReduction_728+happyReduction_728 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut304 happy_x_2 of { (HappyWrap304 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn292 r))++happyReduce_729 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_729 = happySpecReduce_1  277# happyReduction_729+happyReduction_729 happy_x_1+	 =  case happyOut296 happy_x_1 of { (HappyWrap296 happy_var_1) -> +	happyIn293+		 (mkHsVarOpPV happy_var_1+	)}++happyReduce_730 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_730 = happySpecReduce_1  277# happyReduction_730+happyReduction_730 happy_x_1+	 =  case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> +	happyIn293+		 (mkHsConOpPV happy_var_1+	)}++happyReduce_731 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_731 = happySpecReduce_1  277# happyReduction_731+happyReduction_731 happy_x_1+	 =  case happyOut295 happy_x_1 of { (HappyWrap295 happy_var_1) -> +	happyIn293+		 (happy_var_1+	)}++happyReduce_732 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_732 = happySpecReduce_1  278# happyReduction_732+happyReduction_732 happy_x_1+	 =  case happyOut297 happy_x_1 of { (HappyWrap297 happy_var_1) -> +	happyIn294+		 (mkHsVarOpPV happy_var_1+	)}++happyReduce_733 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_733 = happySpecReduce_1  278# happyReduction_733+happyReduction_733 happy_x_1+	 =  case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> +	happyIn294+		 (mkHsConOpPV happy_var_1+	)}++happyReduce_734 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_734 = happySpecReduce_1  278# happyReduction_734+happyReduction_734 happy_x_1+	 =  case happyOut295 happy_x_1 of { (HappyWrap295 happy_var_1) -> +	happyIn294+		 (happy_var_1+	)}++happyReduce_735 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_735 = happySpecReduce_3  279# happyReduction_735+happyReduction_735 happy_x_3+	happy_x_2+	happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	happyIn295+		 (amms (mkHsInfixHolePV (comb2 happy_var_1 happy_var_3))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3]+	)}}}++happyReduce_736 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_736 = happySpecReduce_1  280# happyReduction_736+happyReduction_736 happy_x_1+	 =  case happyOut305 happy_x_1 of { (HappyWrap305 happy_var_1) -> +	happyIn296+		 (happy_var_1+	)}++happyReduce_737 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_737 = happyMonadReduce 3# 280# happyReduction_737+happyReduction_737 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut303 happy_x_2 of { (HappyWrap303 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn296 r))++happyReduce_738 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_738 = happySpecReduce_1  281# happyReduction_738+happyReduction_738 happy_x_1+	 =  case happyOut306 happy_x_1 of { (HappyWrap306 happy_var_1) -> +	happyIn297+		 (happy_var_1+	)}++happyReduce_739 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_739 = happyMonadReduce 3# 281# happyReduction_739+happyReduction_739 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut303 happy_x_2 of { (HappyWrap303 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn297 r))++happyReduce_740 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_740 = happySpecReduce_1  282# happyReduction_740+happyReduction_740 happy_x_1+	 =  case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> +	happyIn298+		 (happy_var_1+	)}++happyReduce_741 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_741 = happyMonadReduce 3# 283# happyReduction_741+happyReduction_741 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2+                                       ,mj AnnBackquote happy_var_3])}}})+	) (\r -> happyReturn (happyIn299 r))++happyReduce_742 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_742 = happySpecReduce_1  284# happyReduction_742+happyReduction_742 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn300+		 (sL1 happy_var_1 $! mkUnqual tvName (getVARID happy_var_1)+	)}++happyReduce_743 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_743 = happySpecReduce_1  284# happyReduction_743+happyReduction_743 happy_x_1+	 =  case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> +	happyIn300+		 (sL1 happy_var_1 $! mkUnqual tvName (unLoc happy_var_1)+	)}++happyReduce_744 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_744 = happySpecReduce_1  284# happyReduction_744+happyReduction_744 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn300+		 (sL1 happy_var_1 $! mkUnqual tvName (fsLit "unsafe")+	)}++happyReduce_745 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_745 = happySpecReduce_1  284# happyReduction_745+happyReduction_745 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn300+		 (sL1 happy_var_1 $! mkUnqual tvName (fsLit "safe")+	)}++happyReduce_746 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_746 = happySpecReduce_1  284# happyReduction_746+happyReduction_746 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn300+		 (sL1 happy_var_1 $! mkUnqual tvName (fsLit "interruptible")+	)}++happyReduce_747 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_747 = happySpecReduce_1  285# happyReduction_747+happyReduction_747 happy_x_1+	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> +	happyIn301+		 (happy_var_1+	)}++happyReduce_748 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_748 = happyMonadReduce 3# 285# happyReduction_748+happyReduction_748 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut308 happy_x_2 of { (HappyWrap308 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn301 r))++happyReduce_749 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_749 = happySpecReduce_1  286# happyReduction_749+happyReduction_749 happy_x_1+	 =  case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> +	happyIn302+		 (happy_var_1+	)}++happyReduce_750 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_750 = happyMonadReduce 3# 286# happyReduction_750+happyReduction_750 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut308 happy_x_2 of { (HappyWrap308 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn302 r))++happyReduce_751 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_751 = happyMonadReduce 3# 286# happyReduction_751+happyReduction_751 (happy_x_3 `HappyStk`+	happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	case happyOut307 happy_x_2 of { (HappyWrap307 happy_var_2) -> +	case happyOutTok happy_x_3 of { happy_var_3 -> +	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))+                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})+	) (\r -> happyReturn (happyIn302 r))++happyReduce_752 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_752 = happySpecReduce_1  287# happyReduction_752+happyReduction_752 happy_x_1+	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> +	happyIn303+		 (happy_var_1+	)}++happyReduce_753 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_753 = happySpecReduce_1  287# happyReduction_753+happyReduction_753 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn303+		 (sL1 happy_var_1 $! mkQual varName (getQVARID happy_var_1)+	)}++happyReduce_754 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_754 = happySpecReduce_1  288# happyReduction_754+happyReduction_754 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (getVARID happy_var_1)+	)}++happyReduce_755 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_755 = happySpecReduce_1  288# happyReduction_755+happyReduction_755 happy_x_1+	 =  case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (unLoc happy_var_1)+	)}++happyReduce_756 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_756 = happySpecReduce_1  288# happyReduction_756+happyReduction_756 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "unsafe")+	)}++happyReduce_757 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_757 = happySpecReduce_1  288# happyReduction_757+happyReduction_757 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "safe")+	)}++happyReduce_758 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_758 = happySpecReduce_1  288# happyReduction_758+happyReduction_758 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "interruptible")+	)}++happyReduce_759 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_759 = happySpecReduce_1  288# happyReduction_759+happyReduction_759 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "forall")+	)}++happyReduce_760 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_760 = happySpecReduce_1  288# happyReduction_760+happyReduction_760 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "family")+	)}++happyReduce_761 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_761 = happySpecReduce_1  288# happyReduction_761+happyReduction_761 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn304+		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "role")+	)}++happyReduce_762 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_762 = happySpecReduce_1  289# happyReduction_762+happyReduction_762 happy_x_1+	 =  case happyOut308 happy_x_1 of { (HappyWrap308 happy_var_1) -> +	happyIn305+		 (happy_var_1+	)}++happyReduce_763 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_763 = happySpecReduce_1  289# happyReduction_763+happyReduction_763 happy_x_1+	 =  case happyOut307 happy_x_1 of { (HappyWrap307 happy_var_1) -> +	happyIn305+		 (happy_var_1+	)}++happyReduce_764 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_764 = happySpecReduce_1  290# happyReduction_764+happyReduction_764 happy_x_1+	 =  case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> +	happyIn306+		 (happy_var_1+	)}++happyReduce_765 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_765 = happySpecReduce_1  290# happyReduction_765+happyReduction_765 happy_x_1+	 =  case happyOut307 happy_x_1 of { (HappyWrap307 happy_var_1) -> +	happyIn306+		 (happy_var_1+	)}++happyReduce_766 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_766 = happySpecReduce_1  291# happyReduction_766+happyReduction_766 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn307+		 (sL1 happy_var_1 $ mkQual varName (getQVARSYM happy_var_1)+	)}++happyReduce_767 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_767 = happySpecReduce_1  292# happyReduction_767+happyReduction_767 happy_x_1+	 =  case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> +	happyIn308+		 (happy_var_1+	)}++happyReduce_768 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_768 = happySpecReduce_1  292# happyReduction_768+happyReduction_768 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn308+		 (sL1 happy_var_1 $ mkUnqual varName (fsLit "-")+	)}++happyReduce_769 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_769 = happySpecReduce_1  293# happyReduction_769+happyReduction_769 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn309+		 (sL1 happy_var_1 $ mkUnqual varName (getVARSYM happy_var_1)+	)}++happyReduce_770 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_770 = happySpecReduce_1  293# happyReduction_770+happyReduction_770 happy_x_1+	 =  case happyOut311 happy_x_1 of { (HappyWrap311 happy_var_1) -> +	happyIn309+		 (sL1 happy_var_1 $ mkUnqual varName (unLoc happy_var_1)+	)}++happyReduce_771 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_771 = happySpecReduce_1  294# happyReduction_771+happyReduction_771 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "as")+	)}++happyReduce_772 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_772 = happySpecReduce_1  294# happyReduction_772+happyReduction_772 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "qualified")+	)}++happyReduce_773 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_773 = happySpecReduce_1  294# happyReduction_773+happyReduction_773 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "hiding")+	)}++happyReduce_774 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_774 = happySpecReduce_1  294# happyReduction_774+happyReduction_774 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "export")+	)}++happyReduce_775 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_775 = happySpecReduce_1  294# happyReduction_775+happyReduction_775 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "label")+	)}++happyReduce_776 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_776 = happySpecReduce_1  294# happyReduction_776+happyReduction_776 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "dynamic")+	)}++happyReduce_777 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_777 = happySpecReduce_1  294# happyReduction_777+happyReduction_777 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "stdcall")+	)}++happyReduce_778 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_778 = happySpecReduce_1  294# happyReduction_778+happyReduction_778 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "ccall")+	)}++happyReduce_779 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_779 = happySpecReduce_1  294# happyReduction_779+happyReduction_779 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "capi")+	)}++happyReduce_780 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_780 = happySpecReduce_1  294# happyReduction_780+happyReduction_780 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "prim")+	)}++happyReduce_781 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_781 = happySpecReduce_1  294# happyReduction_781+happyReduction_781 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "javascript")+	)}++happyReduce_782 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_782 = happySpecReduce_1  294# happyReduction_782+happyReduction_782 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "group")+	)}++happyReduce_783 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_783 = happySpecReduce_1  294# happyReduction_783+happyReduction_783 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "stock")+	)}++happyReduce_784 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_784 = happySpecReduce_1  294# happyReduction_784+happyReduction_784 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "anyclass")+	)}++happyReduce_785 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_785 = happySpecReduce_1  294# happyReduction_785+happyReduction_785 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "via")+	)}++happyReduce_786 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_786 = happySpecReduce_1  294# happyReduction_786+happyReduction_786 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "unit")+	)}++happyReduce_787 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_787 = happySpecReduce_1  294# happyReduction_787+happyReduction_787 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "dependency")+	)}++happyReduce_788 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_788 = happySpecReduce_1  294# happyReduction_788+happyReduction_788 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn310+		 (sL1 happy_var_1 (fsLit "signature")+	)}++happyReduce_789 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_789 = happySpecReduce_1  295# happyReduction_789+happyReduction_789 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn311+		 (sL1 happy_var_1 (fsLit ".")+	)}++happyReduce_790 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_790 = happySpecReduce_1  295# happyReduction_790+happyReduction_790 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn311+		 (sL1 happy_var_1 (fsLit (starSym (isUnicode happy_var_1)))+	)}++happyReduce_791 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_791 = happySpecReduce_1  296# happyReduction_791+happyReduction_791 happy_x_1+	 =  case happyOut313 happy_x_1 of { (HappyWrap313 happy_var_1) -> +	happyIn312+		 (happy_var_1+	)}++happyReduce_792 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_792 = happySpecReduce_1  296# happyReduction_792+happyReduction_792 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn312+		 (sL1 happy_var_1 $! mkQual dataName (getQCONID happy_var_1)+	)}++happyReduce_793 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_793 = happySpecReduce_1  297# happyReduction_793+happyReduction_793 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn313+		 (sL1 happy_var_1 $ mkUnqual dataName (getCONID happy_var_1)+	)}++happyReduce_794 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_794 = happySpecReduce_1  298# happyReduction_794+happyReduction_794 happy_x_1+	 =  case happyOut315 happy_x_1 of { (HappyWrap315 happy_var_1) -> +	happyIn314+		 (happy_var_1+	)}++happyReduce_795 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_795 = happySpecReduce_1  298# happyReduction_795+happyReduction_795 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn314+		 (sL1 happy_var_1 $ mkQual dataName (getQCONSYM happy_var_1)+	)}++happyReduce_796 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_796 = happySpecReduce_1  299# happyReduction_796+happyReduction_796 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn315+		 (sL1 happy_var_1 $ mkUnqual dataName (getCONSYM happy_var_1)+	)}++happyReduce_797 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_797 = happySpecReduce_1  299# happyReduction_797+happyReduction_797 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn315+		 (sL1 happy_var_1 $ consDataCon_RDR+	)}++happyReduce_798 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_798 = happySpecReduce_1  300# happyReduction_798+happyReduction_798 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsChar       (getCHARs happy_var_1) $ getCHAR happy_var_1+	)}++happyReduce_799 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_799 = happySpecReduce_1  300# happyReduction_799+happyReduction_799 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsString     (getSTRINGs happy_var_1)+                                                    $ getSTRING happy_var_1+	)}++happyReduce_800 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_800 = happySpecReduce_1  300# happyReduction_800+happyReduction_800 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsIntPrim    (getPRIMINTEGERs happy_var_1)+                                                    $ getPRIMINTEGER happy_var_1+	)}++happyReduce_801 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_801 = happySpecReduce_1  300# happyReduction_801+happyReduction_801 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsWordPrim   (getPRIMWORDs happy_var_1)+                                                    $ getPRIMWORD happy_var_1+	)}++happyReduce_802 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_802 = happySpecReduce_1  300# happyReduction_802+happyReduction_802 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsCharPrim   (getPRIMCHARs happy_var_1)+                                                    $ getPRIMCHAR happy_var_1+	)}++happyReduce_803 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_803 = happySpecReduce_1  300# happyReduction_803+happyReduction_803 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsStringPrim (getPRIMSTRINGs happy_var_1)+                                                    $ getPRIMSTRING happy_var_1+	)}++happyReduce_804 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_804 = happySpecReduce_1  300# happyReduction_804+happyReduction_804 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsFloatPrim  noExtField $ getPRIMFLOAT happy_var_1+	)}++happyReduce_805 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_805 = happySpecReduce_1  300# happyReduction_805+happyReduction_805 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn316+		 (sL1 happy_var_1 $ HsDoublePrim noExtField $ getPRIMDOUBLE happy_var_1+	)}++happyReduce_806 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_806 = happySpecReduce_1  301# happyReduction_806+happyReduction_806 happy_x_1+	 =  happyIn317+		 (()+	)++happyReduce_807 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_807 = happyMonadReduce 1# 301# happyReduction_807+happyReduction_807 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((( popContext))+	) (\r -> happyReturn (happyIn317 r))++happyReduce_808 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_808 = happySpecReduce_1  302# happyReduction_808+happyReduction_808 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn318+		 (sL1 happy_var_1 $ mkModuleNameFS (getCONID happy_var_1)+	)}++happyReduce_809 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_809 = happySpecReduce_1  302# happyReduction_809+happyReduction_809 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn318+		 (sL1 happy_var_1 $ let (mod,c) = getQCONID happy_var_1 in+                                  mkModuleNameFS+                                   (mkFastString+                                     (unpackFS mod ++ '.':unpackFS c))+	)}++happyReduce_810 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_810 = happySpecReduce_2  303# happyReduction_810+happyReduction_810 happy_x_2+	happy_x_1+	 =  case happyOut319 happy_x_1 of { (HappyWrap319 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn319+		 (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)+	)}}++happyReduce_811 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_811 = happySpecReduce_1  303# happyReduction_811+happyReduction_811 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn319+		 (([gl happy_var_1],1)+	)}++happyReduce_812 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_812 = happySpecReduce_1  304# happyReduction_812+happyReduction_812 happy_x_1+	 =  case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> +	happyIn320+		 (happy_var_1+	)}++happyReduce_813 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_813 = happySpecReduce_0  304# happyReduction_813+happyReduction_813  =  happyIn320+		 (([], 0)+	)++happyReduce_814 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_814 = happySpecReduce_2  305# happyReduction_814+happyReduction_814 happy_x_2+	happy_x_1+	 =  case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> +	case happyOutTok happy_x_2 of { happy_var_2 -> +	happyIn321+		 (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)+	)}}++happyReduce_815 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_815 = happySpecReduce_1  305# happyReduction_815+happyReduction_815 happy_x_1+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> +	happyIn321+		 (([gl happy_var_1],1)+	)}++happyReduce_816 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_816 = happyMonadReduce 1# 306# happyReduction_816+happyReduction_816 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( return (sL1 happy_var_1 (mkHsDocString (getDOCNEXT happy_var_1))))})+	) (\r -> happyReturn (happyIn322 r))++happyReduce_817 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_817 = happyMonadReduce 1# 307# happyReduction_817+happyReduction_817 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( return (sL1 happy_var_1 (mkHsDocString (getDOCPREV happy_var_1))))})+	) (\r -> happyReturn (happyIn323 r))++happyReduce_818 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_818 = happyMonadReduce 1# 308# happyReduction_818+happyReduction_818 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	(+      let string = getDOCNAMED happy_var_1+          (name, rest) = break isSpace string+      in return (sL1 happy_var_1 (name, mkHsDocString rest)))})+	) (\r -> happyReturn (happyIn324 r))++happyReduce_819 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_819 = happyMonadReduce 1# 309# happyReduction_819+happyReduction_819 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( let (n, doc) = getDOCSECTION happy_var_1 in+        return (sL1 happy_var_1 (n, mkHsDocString doc)))})+	) (\r -> happyReturn (happyIn325 r))++happyReduce_820 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_820 = happyMonadReduce 1# 310# happyReduction_820+happyReduction_820 (happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> +	( let string = getDOCNEXT happy_var_1 in+                     return (Just (sL1 happy_var_1 (mkHsDocString string))))})+	) (\r -> happyReturn (happyIn326 r))++happyReduce_821 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_821 = happySpecReduce_1  311# happyReduction_821+happyReduction_821 happy_x_1+	 =  case happyOut323 happy_x_1 of { (HappyWrap323 happy_var_1) -> +	happyIn327+		 (Just happy_var_1+	)}++happyReduce_822 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_822 = happySpecReduce_0  311# happyReduction_822+happyReduction_822  =  happyIn327+		 (Nothing+	)++happyReduce_823 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_823 = happySpecReduce_1  312# happyReduction_823+happyReduction_823 happy_x_1+	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> +	happyIn328+		 (Just happy_var_1+	)}++happyReduce_824 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_824 = happySpecReduce_0  312# happyReduction_824+happyReduction_824  =  happyIn328+		 (Nothing+	)++happyReduce_825 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_825 = happyMonadReduce 2# 313# happyReduction_825+happyReduction_825 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut215 happy_x_1 of { (HappyWrap215 happy_var_1) -> +	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+         fmap ecpFromExp $+         ams (sLL happy_var_1 happy_var_2 $ HsPragE noExtField (snd $ unLoc happy_var_1) happy_var_2)+             (fst $ unLoc happy_var_1))}})+	) (\r -> happyReturn (happyIn329 r))++happyReduce_826 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )+happyReduce_826 = happyMonadReduce 2# 314# happyReduction_826+happyReduction_826 (happy_x_2 `HappyStk`+	happy_x_1 `HappyStk`+	happyRest) tk+	 = happyThen ((case happyOut215 happy_x_1 of { (HappyWrap215 happy_var_1) -> +	case happyOut212 happy_x_2 of { (HappyWrap212 happy_var_2) -> +	( runECP_P happy_var_2 >>= \ happy_var_2 ->+         fmap ecpFromExp $+         ams (sLL happy_var_1 happy_var_2 $ HsPragE noExtField (snd $ unLoc happy_var_1) happy_var_2)+             (fst $ unLoc happy_var_1))}})+	) (\r -> happyReturn (happyIn330 r))++happyNewToken action sts stk+	= (lexer True)(\tk -> +	let cont i = happyDoAction i tk action sts stk in+	case tk of {+	L _ ITeof -> happyDoAction 149# tk action sts stk;+	L _ ITunderscore -> cont 1#;+	L _ ITas -> cont 2#;+	L _ ITcase -> cont 3#;+	L _ ITclass -> cont 4#;+	L _ ITdata -> cont 5#;+	L _ ITdefault -> cont 6#;+	L _ ITderiving -> cont 7#;+	L _ ITdo -> cont 8#;+	L _ ITelse -> cont 9#;+	L _ IThiding -> cont 10#;+	L _ ITif -> cont 11#;+	L _ ITimport -> cont 12#;+	L _ ITin -> cont 13#;+	L _ ITinfix -> cont 14#;+	L _ ITinfixl -> cont 15#;+	L _ ITinfixr -> cont 16#;+	L _ ITinstance -> cont 17#;+	L _ ITlet -> cont 18#;+	L _ ITmodule -> cont 19#;+	L _ ITnewtype -> cont 20#;+	L _ ITof -> cont 21#;+	L _ ITqualified -> cont 22#;+	L _ ITthen -> cont 23#;+	L _ ITtype -> cont 24#;+	L _ ITwhere -> cont 25#;+	L _ (ITforall _) -> cont 26#;+	L _ ITforeign -> cont 27#;+	L _ ITexport -> cont 28#;+	L _ ITlabel -> cont 29#;+	L _ ITdynamic -> cont 30#;+	L _ ITsafe -> cont 31#;+	L _ ITinterruptible -> cont 32#;+	L _ ITunsafe -> cont 33#;+	L _ ITmdo -> cont 34#;+	L _ ITfamily -> cont 35#;+	L _ ITrole -> cont 36#;+	L _ ITstdcallconv -> cont 37#;+	L _ ITccallconv -> cont 38#;+	L _ ITcapiconv -> cont 39#;+	L _ ITprimcallconv -> cont 40#;+	L _ ITjavascriptcallconv -> cont 41#;+	L _ ITproc -> cont 42#;+	L _ ITrec -> cont 43#;+	L _ ITgroup -> cont 44#;+	L _ ITby -> cont 45#;+	L _ ITusing -> cont 46#;+	L _ ITpattern -> cont 47#;+	L _ ITstatic -> cont 48#;+	L _ ITstock -> cont 49#;+	L _ ITanyclass -> cont 50#;+	L _ ITvia -> cont 51#;+	L _ ITunit -> cont 52#;+	L _ ITsignature -> cont 53#;+	L _ ITdependency -> cont 54#;+	L _ (ITinline_prag _ _ _) -> cont 55#;+	L _ (ITspec_prag _) -> cont 56#;+	L _ (ITspec_inline_prag _ _) -> cont 57#;+	L _ (ITsource_prag _) -> cont 58#;+	L _ (ITrules_prag _) -> cont 59#;+	L _ (ITcore_prag _) -> cont 60#;+	L _ (ITscc_prag _) -> cont 61#;+	L _ (ITgenerated_prag _) -> cont 62#;+	L _ (ITdeprecated_prag _) -> cont 63#;+	L _ (ITwarning_prag _) -> cont 64#;+	L _ (ITunpack_prag _) -> cont 65#;+	L _ (ITnounpack_prag _) -> cont 66#;+	L _ (ITann_prag _) -> cont 67#;+	L _ (ITminimal_prag _) -> cont 68#;+	L _ (ITctype _) -> cont 69#;+	L _ (IToverlapping_prag _) -> cont 70#;+	L _ (IToverlappable_prag _) -> cont 71#;+	L _ (IToverlaps_prag _) -> cont 72#;+	L _ (ITincoherent_prag _) -> cont 73#;+	L _ (ITcomplete_prag _) -> cont 74#;+	L _ ITclose_prag -> cont 75#;+	L _ ITdotdot -> cont 76#;+	L _ ITcolon -> cont 77#;+	L _ (ITdcolon _) -> cont 78#;+	L _ ITequal -> cont 79#;+	L _ ITlam -> cont 80#;+	L _ ITlcase -> cont 81#;+	L _ ITvbar -> cont 82#;+	L _ (ITlarrow _) -> cont 83#;+	L _ (ITrarrow _) -> cont 84#;+	L _ ITat -> cont 85#;+	L _ (ITdarrow _) -> cont 86#;+	L _ ITminus -> cont 87#;+	L _ ITtilde -> cont 88#;+	L _ ITbang -> cont 89#;+	L _ (ITstar _) -> cont 90#;+	L _ (ITlarrowtail _) -> cont 91#;+	L _ (ITrarrowtail _) -> cont 92#;+	L _ (ITLarrowtail _) -> cont 93#;+	L _ (ITRarrowtail _) -> cont 94#;+	L _ ITdot -> cont 95#;+	L _ ITtypeApp -> cont 96#;+	L _ ITocurly -> cont 97#;+	L _ ITccurly -> cont 98#;+	L _ ITvocurly -> cont 99#;+	L _ ITvccurly -> cont 100#;+	L _ ITobrack -> cont 101#;+	L _ ITcbrack -> cont 102#;+	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 149# tk = happyError' (tk, explist)+happyError_ explist _ tk = happyError' (tk, explist)++happyThen :: () => P a -> (a -> P b) -> P b+happyThen = (>>=)+happyReturn :: () => a -> P a+happyReturn = (return)+happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn )++happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )++happyDoAction :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )++happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn ))++happyThen1 :: () => P a -> (a -> P b) -> P b+happyThen1 = happyThen+happyReturn1 :: () => a -> P a+happyReturn1 = happyReturn+happyError' :: () => (((Located Token)), [String]) -> P a+happyError' tk = (\(tokens, explist) -> happyError) tk+parseModule = happySomeParser where+ happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {(HappyWrap34 x') = happyOut34 x} in x'))++parseSignature = happySomeParser where+ happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (let {(HappyWrap33 x') = happyOut33 x} in x'))++parseImport = happySomeParser where+ happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (let {(HappyWrap64 x') = happyOut64 x} in x'))++parseStatement = happySomeParser where+ happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (let {(HappyWrap255 x') = happyOut255 x} in x'))++parseDeclaration = happySomeParser where+ happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (let {(HappyWrap77 x') = happyOut77 x} in x'))++parseExpression = happySomeParser where+ happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (let {(HappyWrap210 x') = happyOut210 x} in x'))++parsePattern = happySomeParser where+ happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (let {(HappyWrap248 x') = happyOut248 x} in x'))++parseTypeSignature = happySomeParser where+ happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (let {(HappyWrap206 x') = happyOut206 x} in x'))++parseStmt = happySomeParser where+ happySomeParser = happyThen (happyParse 8#) (\x -> happyReturn (let {(HappyWrap254 x') = happyOut254 x} in x'))++parseIdentifier = happySomeParser where+ happySomeParser = happyThen (happyParse 9#) (\x -> happyReturn (let {(HappyWrap16 x') = happyOut16 x} in x'))++parseType = happySomeParser where+ happySomeParser = happyThen (happyParse 10#) (\x -> happyReturn (let {(HappyWrap156 x') = happyOut156 x} in x'))++parseBackpack = happySomeParser where+ happySomeParser = happyThen (happyParse 11#) (\x -> happyReturn (let {(HappyWrap17 x') = happyOut17 x} in x'))++parseHeader = happySomeParser where+ happySomeParser = happyThen (happyParse 12#) (\x -> happyReturn (let {(HappyWrap43 x') = happyOut43 x} in x'))++happySeq = happyDoSeq+++happyError :: P a+happyError = srcParseFail++getVARID        (L _ (ITvarid    x)) = x+getCONID        (L _ (ITconid    x)) = x+getVARSYM       (L _ (ITvarsym   x)) = x+getCONSYM       (L _ (ITconsym   x)) = x+getQVARID       (L _ (ITqvarid   x)) = x+getQCONID       (L _ (ITqconid   x)) = x+getQVARSYM      (L _ (ITqvarsym  x)) = x+getQCONSYM      (L _ (ITqconsym  x)) = x+getIPDUPVARID   (L _ (ITdupipvarid   x)) = x+getLABELVARID   (L _ (ITlabelvarid   x)) = x+getCHAR         (L _ (ITchar   _ x)) = x+getSTRING       (L _ (ITstring _ x)) = x+getINTEGER      (L _ (ITinteger x))  = x+getRATIONAL     (L _ (ITrational x)) = x+getPRIMCHAR     (L _ (ITprimchar _ x)) = x+getPRIMSTRING   (L _ (ITprimstring _ x)) = x+getPRIMINTEGER  (L _ (ITprimint  _ x)) = x+getPRIMWORD     (L _ (ITprimword _ x)) = x+getPRIMFLOAT    (L _ (ITprimfloat x)) = x+getPRIMDOUBLE   (L _ (ITprimdouble x)) = x+getINLINE       (L _ (ITinline_prag _ inl conl)) = (inl,conl)+getSPEC_INLINE  (L _ (ITspec_inline_prag _ True))  = (Inline,  FunLike)+getSPEC_INLINE  (L _ (ITspec_inline_prag _ False)) = (NoInline,FunLike)+getCOMPLETE_PRAGs (L _ (ITcomplete_prag x)) = x++getDOCNEXT (L _ (ITdocCommentNext x)) = x+getDOCPREV (L _ (ITdocCommentPrev x)) = x+getDOCNAMED (L _ (ITdocCommentNamed x)) = x+getDOCSECTION (L _ (ITdocSection n x)) = (n, x)++getINTEGERs     (L _ (ITinteger (IL src _ _))) = src+getCHARs        (L _ (ITchar       src _)) = src+getSTRINGs      (L _ (ITstring     src _)) = src+getPRIMCHARs    (L _ (ITprimchar   src _)) = src+getPRIMSTRINGs  (L _ (ITprimstring src _)) = src+getPRIMINTEGERs (L _ (ITprimint    src _)) = src+getPRIMWORDs    (L _ (ITprimword   src _)) = src++-- See Note [Pragma source text] in BasicTypes for the following+getINLINE_PRAGs       (L _ (ITinline_prag       src _ _)) = src+getSPEC_PRAGs         (L _ (ITspec_prag         src))     = src+getSPEC_INLINE_PRAGs  (L _ (ITspec_inline_prag  src _))   = src+getSOURCE_PRAGs       (L _ (ITsource_prag       src)) = src+getRULES_PRAGs        (L _ (ITrules_prag        src)) = src+getWARNING_PRAGs      (L _ (ITwarning_prag      src)) = src+getDEPRECATED_PRAGs   (L _ (ITdeprecated_prag   src)) = src+getSCC_PRAGs          (L _ (ITscc_prag          src)) = src+getGENERATED_PRAGs    (L _ (ITgenerated_prag    src)) = src+getCORE_PRAGs         (L _ (ITcore_prag         src)) = src+getUNPACK_PRAGs       (L _ (ITunpack_prag       src)) = src+getNOUNPACK_PRAGs     (L _ (ITnounpack_prag     src)) = src+getANN_PRAGs          (L _ (ITann_prag          src)) = src+getMINIMAL_PRAGs      (L _ (ITminimal_prag      src)) = src+getOVERLAPPABLE_PRAGs (L _ (IToverlappable_prag src)) = src+getOVERLAPPING_PRAGs  (L _ (IToverlapping_prag  src)) = src+getOVERLAPS_PRAGs     (L _ (IToverlaps_prag     src)) = src+getINCOHERENT_PRAGs   (L _ (ITincoherent_prag   src)) = src+getCTYPEs             (L _ (ITctype             src)) = src++getStringLiteral l = StringLiteral (getSTRINGs l) (getSTRING l)++isUnicode :: Located Token -> Bool+isUnicode (L _ (ITforall         iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITdarrow         iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITdcolon         iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITlarrow         iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITrarrow         iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITlarrowtail     iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITrarrowtail     iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITLarrowtail     iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITRarrowtail     iu)) = iu == UnicodeSyntax+isUnicode (L _ (IToparenbar      iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITcparenbar      iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITopenExpQuote _ iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITcloseQuote     iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITstar           iu)) = iu == UnicodeSyntax+isUnicode _                           = False++hasE :: Located Token -> Bool+hasE (L _ (ITopenExpQuote HasE _)) = True+hasE (L _ (ITopenTExpQuote HasE))  = True+hasE _                             = False++getSCC :: Located Token -> P FastString+getSCC lt = do let s = getSTRING lt+                   err = "Spaces are not allowed in SCCs"+               -- We probably actually want to be more restrictive than this+               if ' ' `elem` unpackFS s+                   then addFatalError (getLoc lt) (text err)+                   else return s++-- Utilities for combining source spans+comb2 :: Located a -> Located b -> SrcSpan+comb2 a b = a `seq` b `seq` combineLocs a b++comb3 :: Located a -> Located b -> Located c -> SrcSpan+comb3 a b c = a `seq` b `seq` c `seq`+    combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))++comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan+comb4 a b c d = a `seq` b `seq` c `seq` d `seq`+    (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $+                combineSrcSpans (getLoc c) (getLoc d))++-- strict constructor version:+{-# INLINE sL #-}+sL :: SrcSpan -> a -> Located a+sL span a = span `seq` a `seq` L span a++-- See Note [Adding location info] for how these utility functions are used++-- replaced last 3 CPP macros in this file+{-# INLINE sL0 #-}+sL0 :: a -> Located a+sL0 = L noSrcSpan       -- #define L0   L noSrcSpan++{-# INLINE sL1 #-}+sL1 :: Located a -> b -> Located b+sL1 x = sL (getLoc x)   -- #define sL1   sL (getLoc $1)++{-# INLINE sLL #-}+sLL :: Located a -> Located b -> c -> Located c+sLL x y = sL (comb2 x y) -- #define LL   sL (comb2 $1 $>)++{- Note [Adding location info]+   ~~~~~~~~~~~~~~~~~~~~~~~~~~~++This is done using the three functions below, sL0, sL1+and sLL.  Note that these functions were mechanically+converted from the three macros that used to exist before,+namely L0, L1 and LL.++They each add a SrcSpan to their argument.++   sL0  adds 'noSrcSpan', used for empty productions+     -- This doesn't seem to work anymore -=chak++   sL1  for a production with a single token on the lhs.  Grabs the SrcSpan+        from that token.++   sLL  for a production with >1 token on the lhs.  Makes up a SrcSpan from+        the first and last tokens.++These suffice for the majority of cases.  However, we must be+especially careful with empty productions: sLL won't work if the first+or last token on the lhs can represent an empty span.  In these cases,+we have to calculate the span using more of the tokens from the lhs, eg.++        | 'newtype' tycl_hdr '=' newconstr deriving+                { L (comb3 $1 $4 $5)+                    (mkTyData NewType (unLoc $2) $4 (unLoc $5)) }++We provide comb3 and comb4 functions which are useful in such cases.++Be careful: there's no checking that you actually got this right, the+only symptom will be that the SrcSpans of your syntax will be+incorrect.++-}++-- Make a source location for the file.  We're a bit lazy here and just+-- make a point SrcSpan at line 1, column 0.  Strictly speaking we should+-- try to find the span of the whole file (ToDo).+fileSrcSpan :: P SrcSpan+fileSrcSpan = do+  l <- getRealSrcLoc;+  let loc = mkSrcLoc (srcLocFile l) 1 1;+  return (mkSrcSpan loc loc)++-- Hint about the MultiWayIf extension+hintMultiWayIf :: SrcSpan -> P ()+hintMultiWayIf span = do+  mwiEnabled <- getBit MultiWayIfBit+  unless mwiEnabled $ addError span $+    text "Multi-way if-expressions need MultiWayIf turned on"++-- Hint about explicit-forall+hintExplicitForall :: Located Token -> P ()+hintExplicitForall tok = do+    forall   <- getBit ExplicitForallBit+    rulePrag <- getBit InRulePragBit+    unless (forall || rulePrag) $ addError (getLoc tok) $ vcat+      [ text "Illegal symbol" <+> quotes forallSymDoc <+> text "in type"+      , text "Perhaps you intended to use RankNTypes or a similar language"+      , text "extension to enable explicit-forall syntax:" <+>+        forallSymDoc <+> text "<tvs>. <type>"+      ]+  where+    forallSymDoc = text (forallSym (isUnicode tok))++-- When two single quotes don't followed by tyvar or gtycon, we report the+-- error as empty character literal, or TH quote that missing proper type+-- variable or constructor. See #13450.+reportEmptyDoubleQuotes :: SrcSpan -> P a+reportEmptyDoubleQuotes span = do+    thQuotes <- getBit ThQuotesBit+    if thQuotes+      then addFatalError span $ vcat+        [ text "Parser error on `''`"+        , text "Character literals may not be empty"+        , text "Or perhaps you intended to use quotation syntax of TemplateHaskell,"+        , text "but the type variable or constructor is missing"+        ]+      else addFatalError span $ vcat+        [ text "Parser error on `''`"+        , text "Character literals may not be empty"+        ]++{-+%************************************************************************+%*                                                                      *+        Helper functions for generating annotations in the parser+%*                                                                      *+%************************************************************************++For the general principles of the following routines, see Note [Api annotations]+in GHC.Parser.Annotation++-}++-- |Construct an AddAnn from the annotation keyword and the location+-- of the keyword itself+mj :: AnnKeywordId -> Located e -> AddAnn+mj a l = AddAnn a (gl l)+++-- |Construct an AddAnn from the annotation keyword and the Located Token. If+-- the token has a unicode equivalent and this has been used, provide the+-- unicode variant of the annotation.+mu :: AnnKeywordId -> Located Token -> AddAnn+mu a lt@(L l t) = AddAnn (toUnicodeAnn a lt) l++-- | If the 'Token' is using its unicode variant return the unicode variant of+--   the annotation+toUnicodeAnn :: AnnKeywordId -> Located Token -> AnnKeywordId+toUnicodeAnn a t = if isUnicode t then unicodeAnn a else a++gl :: Located a -> SrcSpan+gl = getLoc++-- |Add an annotation to the located element, and return the located+-- element as a pass through+aa :: Located a -> (AnnKeywordId, Located c) -> P (Located a)+aa a@(L l _) (b,s) = addAnnotation l b (gl s) >> return a++-- |Add an annotation to a located element resulting from a monadic action+am :: P (Located a) -> (AnnKeywordId, Located b) -> P (Located a)+am a (b,s) = do+  av@(L l _) <- a+  addAnnotation l b (gl s)+  return av++-- | Add a list of AddAnns to the given AST element.  For example,+-- the parsing rule for @let@ looks like:+--+-- @+--      | 'let' binds 'in' exp    {% ams (sLL $1 $> $ HsLet (snd $ unLoc $2) $4)+--                                       (mj AnnLet $1:mj AnnIn $3+--                                         :(fst $ unLoc $2)) }+-- @+--+-- This adds an AnnLet annotation for @let@, an AnnIn for @in@, as well+-- as any annotations that may arise in the binds. This will include open+-- and closing braces if they are used to delimit the let expressions.+--+ams :: MonadP m => Located a -> [AddAnn] -> m (Located a)+ams a@(L l _) bs = addAnnsAt l bs >> return a++amsL :: SrcSpan -> [AddAnn] -> P ()+amsL sp bs = addAnnsAt sp bs >> return ()++-- |Add all [AddAnn] to an AST element, and wrap it in a 'Just'+ajs :: MonadP m => Located a -> [AddAnn] -> m (Maybe (Located a))+ajs a bs = Just <$> ams a bs++-- |Add a list of AddAnns to the given AST element, where the AST element is the+--  result of a monadic action+amms :: MonadP m => m (Located a) -> [AddAnn] -> m (Located a)+amms a bs = do { av@(L l _) <- a+               ; addAnnsAt l bs+               ; return av }++-- |Add a list of AddAnns to the AST element, and return the element as a+--  OrdList+amsu :: Located a -> [AddAnn] -> P (OrdList (Located a))+amsu a@(L l _) bs = addAnnsAt l bs >> return (unitOL a)++-- |Synonyms for AddAnn versions of AnnOpen and AnnClose+mo,mc :: Located Token -> AddAnn+mo ll = mj AnnOpen ll+mc ll = mj AnnClose ll++moc,mcc :: Located Token -> AddAnn+moc ll = mj AnnOpenC ll+mcc ll = mj AnnCloseC ll++mop,mcp :: Located Token -> AddAnn+mop ll = mj AnnOpenP ll+mcp ll = mj AnnCloseP ll++mos,mcs :: Located Token -> AddAnn+mos ll = mj AnnOpenS ll+mcs ll = mj AnnCloseS ll++-- |Given a list of the locations of commas, provide a [AddAnn] with an AnnComma+--  entry for each SrcSpan+mcommas :: [SrcSpan] -> [AddAnn]+mcommas = map (AddAnn AnnCommaTuple)++-- |Given a list of the locations of '|'s, provide a [AddAnn] with an AnnVbar+--  entry for each SrcSpan+mvbars :: [SrcSpan] -> [AddAnn]+mvbars = map (AddAnn AnnVbar)++-- |Get the location of the last element of a OrdList, or noSrcSpan+oll :: OrdList (Located a) -> SrcSpan+oll l =+  if isNilOL l then noSrcSpan+               else getLoc (lastOL l)++-- |Add a semicolon annotation in the right place in a list. If the+-- leading list is empty, add it to the tail+asl :: [Located a] -> Located b -> Located a -> P ()+asl [] (L ls _) (L l _) = addAnnotation l          AnnSemi ls+asl (x:_xs) (L ls _) _x = addAnnotation (getLoc x) AnnSemi ls+{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $++++++++++++++-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ > 706+#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool)+#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool)+#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool)+#else+#define LT(n,m) (n Happy_GHC_Exts.<# m)+#define GTE(n,m) (n Happy_GHC_Exts.>=# m)+#define EQ(n,m) (n Happy_GHC_Exts.==# m)+#endif++++++++++++++++++++data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList+++++++++++++++++++++++++++++++++++++++++infixr 9 `HappyStk`+data HappyStk a = HappyStk a (HappyStk a)++-----------------------------------------------------------------------------+-- starting the parse++happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll++-----------------------------------------------------------------------------+-- Accepting the parse++-- If the current token is ERROR_TOK, it means we've just accepted a partial+-- parse (a %partial parser).  We must ignore the saved token on the top of+-- the stack in this case.+happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =+        happyReturn1 ans+happyAccept j tk st sts (HappyStk ans _) = +        (happyTcHack j (happyTcHack st)) (happyReturn1 ans)++-----------------------------------------------------------------------------+-- Arrays only: do the next action++++happyDoAction i tk st+        = {- nothing -}+          case action of+                0#           -> {- nothing -}+                                     happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st+                -1#          -> {- nothing -}+                                     happyAccept i tk st+                n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}+                                                   (happyReduceArr Happy_Data_Array.! rule) i tk st+                                                   where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))+                n                 -> {- nothing -}+                                     happyShift new_state i tk st+                                     where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))+   where off    = happyAdjustOffset (indexShortOffAddr happyActOffsets st)+         off_i  = (off Happy_GHC_Exts.+# i)+         check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))+                  then EQ(indexShortOffAddr happyCheck off_i, i)+                  else False+         action+          | check     = indexShortOffAddr happyTable off_i+          | otherwise = indexShortOffAddr happyDefActions st+++++indexShortOffAddr (HappyA# arr) off =+        Happy_GHC_Exts.narrow16Int# i+  where+        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)+        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))+        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))+        off' = off Happy_GHC_Exts.*# 2#+++++{-# INLINE happyLt #-}+happyLt x y = LT(x,y)+++readArrayBit arr bit =+    Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16)+  where unbox_int (Happy_GHC_Exts.I# x) = x+++++++data HappyAddr = HappyA# Happy_GHC_Exts.Addr#+++-----------------------------------------------------------------------------+-- HappyState data type (not arrays)++++++++++++++-----------------------------------------------------------------------------+-- Shifting a token++happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =+     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in+--     trace "shifting the error token" $+     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)++happyShift new_state i tk st sts stk =+     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)++-- happyReduce is specialised for the common cases.++happySpecReduce_0 i fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happySpecReduce_0 nt fn j tk st@((action)) sts stk+     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)++happySpecReduce_1 i fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')+     = let r = fn v1 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_2 i fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')+     = let r = fn v1 v2 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happySpecReduce_3 i fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')+     = let r = fn v1 v2 v3 in+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))++happyReduce k i fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happyReduce k nt fn j tk st sts stk+     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of+         sts1@((HappyCons (st1@(action)) (_))) ->+                let r = fn stk in  -- it doesn't hurt to always seq here...+                happyDoSeq r (happyGoto nt j tk st1 sts1 r)++happyMonadReduce k nt fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happyMonadReduce k nt fn j tk st sts stk =+      case happyDrop k (HappyCons (st) (sts)) of+        sts1@((HappyCons (st1@(action)) (_))) ->+          let drop_stk = happyDropStk k stk in+          happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))++happyMonad2Reduce k nt fn 0# tk st sts stk+     = happyFail [] 0# tk st sts stk+happyMonad2Reduce k nt fn j tk st sts stk =+      case happyDrop k (HappyCons (st) (sts)) of+        sts1@((HappyCons (st1@(action)) (_))) ->+         let drop_stk = happyDropStk k stk++             off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1)+             off_i = (off Happy_GHC_Exts.+# nt)+             new_state = indexShortOffAddr happyTable off_i+++++          in+          happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))++happyDrop 0# l = l+happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t++happyDropStk 0# l = l+happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs++-----------------------------------------------------------------------------+-- Moving to a new state after a reduction+++happyGoto nt j tk st = +   {- nothing -}+   happyDoAction j tk new_state+   where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st)+         off_i = (off Happy_GHC_Exts.+# nt)+         new_state = indexShortOffAddr happyTable off_i+++++-----------------------------------------------------------------------------+-- Error recovery (ERROR_TOK is the error token)++-- parse error if we are in recovery and we fail again+happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) =+     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in+--      trace "failing" $ +        happyError_ explist i tk++{-  We don't need state discarding for our restricted implementation of+    "error".  In fact, it can cause some bogus parses, so I've disabled it+    for now --SDM++-- discard a state+happyFail  ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) +                                                (saved_tok `HappyStk` _ `HappyStk` stk) =+--      trace ("discarding state, depth " ++ show (length stk))  $+        DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk))+-}++-- Enter error recovery: generate an error token,+--                       save the old token and carry on.+happyFail explist i tk (action) sts stk =+--      trace "entering error recovery" $+        happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)++-- Internal happy errors:++notHappyAtAll :: a+notHappyAtAll = error "Internal Happy error\n"++-----------------------------------------------------------------------------+-- Hack to get the typechecker to accept our action functions+++happyTcHack :: Happy_GHC_Exts.Int# -> a -> a+happyTcHack x y = y+{-# INLINE happyTcHack #-}+++-----------------------------------------------------------------------------+-- Seq-ing.  If the --strict flag is given, then Happy emits +--      happySeq = happyDoSeq+-- otherwise it emits+--      happySeq = happyDontSeq++happyDoSeq, happyDontSeq :: a -> b -> b+happyDoSeq   a b = a `seq` b+happyDontSeq a b = b++-----------------------------------------------------------------------------+-- Don't inline any functions from the template.  GHC has a nasty habit+-- of deciding to inline happyGoto everywhere, which increases the size of+-- the generated parser quite a bit.+++{-# NOINLINE happyDoAction #-}+{-# NOINLINE happyTable #-}+{-# NOINLINE happyCheck #-}+{-# NOINLINE happyActOffsets #-}+{-# NOINLINE happyGotoOffsets #-}+{-# NOINLINE happyDefActions #-}++{-# NOINLINE happyShift #-}+{-# NOINLINE happySpecReduce_0 #-}+{-# NOINLINE happySpecReduce_1 #-}+{-# NOINLINE happySpecReduce_2 #-}+{-# NOINLINE happySpecReduce_3 #-}+{-# NOINLINE happyReduce #-}+{-# NOINLINE happyMonadReduce #-}+{-# NOINLINE happyGoto #-}+{-# NOINLINE happyFail #-}++-- end of Happy Template.
+ ghc-lib/stage0/compiler/build/GHC/Parser/Lexer.hs view
@@ -0,0 +1,3567 @@+{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-missing-signatures #-}+{-# LANGUAGE CPP,MagicHash #-}+{-# LINE 43 "compiler/GHC/Parser/Lexer.x" #-}++{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE MultiWayIf #-}++{-# OPTIONS_GHC -funbox-strict-fields #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++module GHC.Parser.Lexer (+   Token(..), lexer, lexerDbg, pragState, mkPState, mkPStatePure, PState(..),+   P(..), ParseResult(..), mkParserFlags, mkParserFlags', ParserFlags(..),+   appendWarning,+   appendError,+   allocateComments,+   MonadP(..),+   getRealSrcLoc, getPState, withThisPackage,+   failMsgP, failLocMsgP, srcParseFail,+   getErrorMessages, getMessages,+   popContext, pushModuleContext, setLastToken, setSrcLoc,+   activeContext, nextIsEOF,+   getLexState, popLexState, pushLexState,+   ExtBits(..),+   xtest,+   lexTokenStream,+   AddAnn(..),mkParensApiAnn,+   addAnnsAt,+   commentToAnnotation+  ) where++import GHC.Prelude++-- base+import Control.Monad+import Data.Bits+import Data.Char+import Data.List+import Data.Maybe+import Data.Word++import GHC.Data.EnumSet as EnumSet++-- ghc-boot+import qualified GHC.LanguageExtensions as LangExt++-- bytestring+import Data.ByteString (ByteString)++-- containers+import Data.Map (Map)+import qualified Data.Map as Map++-- compiler/utils+import GHC.Data.Bag+import GHC.Utils.Outputable+import GHC.Data.StringBuffer+import GHC.Data.FastString+import GHC.Types.Unique.FM+import GHC.Utils.Misc ( readRational, readHexRational )++-- compiler/main+import GHC.Utils.Error+import GHC.Driver.Session as DynFlags++-- compiler/basicTypes+import GHC.Types.SrcLoc+import GHC.Unit+import GHC.Types.Basic ( InlineSpec(..), RuleMatchInfo(..),+                         IntegralLit(..), FractionalLit(..),+                         SourceText(..) )++-- compiler/parser+import GHC.Parser.CharClass++import GHC.Parser.Annotation++#if __GLASGOW_HASKELL__ >= 603+#include "ghcconfig.h"+#elif defined(__GLASGOW_HASKELL__)+#include "config.h"+#endif+#if __GLASGOW_HASKELL__ >= 503+import Data.Array+#else+import Array+#endif+#if __GLASGOW_HASKELL__ >= 503+import Data.Array.Base (unsafeAt)+import GHC.Exts+#else+import GlaExts+#endif+alex_tab_size :: Int+alex_tab_size = 8+alex_base :: AlexAddr+alex_base = AlexA#+  "\x01\x00\x00\x00\x7b\x00\x00\x00\x84\x00\x00\x00\xa0\x00\x00\x00\xbc\x00\x00\x00\xc5\x00\x00\x00\xce\x00\x00\x00\xec\x00\x00\x00\x06\x01\x00\x00\x22\x01\x00\x00\x3f\x01\x00\x00\x7b\x01\x00\x00\xd4\xff\xff\xff\x61\x00\x00\x00\xd7\xff\xff\xff\xdb\xff\xff\xff\xa4\xff\xff\xff\xaa\xff\xff\xff\xf8\x01\x00\x00\x72\x02\x00\x00\xec\x02\x00\x00\x93\xff\xff\xff\x94\xff\xff\xff\x66\x03\x00\x00\x95\xff\xff\xff\xb2\xff\xff\xff\xe7\xff\xff\xff\xe8\xff\xff\xff\xe9\xff\xff\xff\xd1\x00\x00\x00\xae\xff\xff\xff\xab\xff\xff\xff\xb0\xff\xff\xff\x59\x01\x00\x00\xdc\x03\x00\x00\xfc\x01\x00\x00\xe6\x03\x00\x00\xb3\xff\xff\xff\xba\xff\xff\xff\xac\xff\xff\xff\x3d\x01\x00\x00\x7a\x01\x00\x00\x50\x02\x00\x00\xca\x02\x00\x00\x1f\x04\x00\x00\xfa\x03\x00\x00\x59\x04\x00\x00\x95\x01\x00\x00\x05\x02\x00\x00\xaf\xff\xff\xff\xb1\xff\xff\xff\xa4\x04\x00\x00\xe5\x04\x00\x00\x63\x02\x00\x00\x44\x03\x00\x00\xdd\x02\x00\x00\xfc\x04\x00\x00\x3d\x05\x00\x00\x57\x03\x00\x00\xc5\x04\x00\x00\x1d\x05\x00\x00\x59\x05\x00\x00\x63\x05\x00\x00\x79\x05\x00\x00\x83\x05\x00\x00\x99\x05\x00\x00\xa9\x05\x00\x00\xb3\x05\x00\x00\xbd\x05\x00\x00\xc9\x05\x00\x00\xd3\x05\x00\x00\xed\x05\x00\x00\x04\x06\x00\x00\x63\x00\x00\x00\x51\x00\x00\x00\x26\x06\x00\x00\x4b\x06\x00\x00\x62\x06\x00\x00\xc4\x03\x00\x00\x6c\x00\x00\x00\x84\x06\x00\x00\xbd\x06\x00\x00\x17\x07\x00\x00\x95\x07\x00\x00\x11\x08\x00\x00\x8d\x08\x00\x00\x09\x09\x00\x00\x85\x09\x00\x00\x01\x0a\x00\x00\xb9\x00\x00\x00\x7d\x0a\x00\x00\xfb\x0a\x00\x00\x12\x00\x00\x00\x16\x00\x00\x00\x2d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\xfa\x01\x00\x00\xe0\x03\x00\x00\x67\x00\x00\x00\x9c\x00\x00\x00\x81\x00\x00\x00\x82\x00\x00\x00\x88\x00\x00\x00\x95\x00\x00\x00\x96\x00\x00\x00\x97\x00\x00\x00\x76\x0b\x00\x00\x9e\x0b\x00\x00\xe1\x0b\x00\x00\x09\x0c\x00\x00\x4c\x0c\x00\x00\x74\x0c\x00\x00\xb7\x0c\x00\x00\xe7\x04\x00\x00\x94\x07\x00\x00\x10\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x0c\x00\x00\x71\x0d\x00\x00\xeb\x0d\x00\x00\x65\x0e\x00\x00\xdf\x0e\x00\x00\xa8\x00\x00\x00\xa9\x00\x00\x00\x5d\x0f\x00\x00\x9d\x00\x00\x00\xd7\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x10\x00\x00\x00\x00\x00\x00\xcf\x10\x00\x00\x49\x11\x00\x00\x00\x00\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x11\x00\x00\x3d\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\xf3\x12\x00\x00\x6d\x13\x00\x00\xe7\x13\x00\x00\x61\x14\x00\x00\xdb\x14\x00\x00\x55\x15\x00\x00\xcf\x15\x00\x00\x49\x16\x00\x00\xc3\x16\x00\x00\x3d\x17\x00\x00\xb7\x17\x00\x00\x31\x18\x00\x00\xab\x18\x00\x00\x25\x19\x00\x00\xa1\x00\x00\x00\xbd\x00\x00\x00\xbe\x00\x00\x00\xbf\x00\x00\x00\xc1\x00\x00\x00\xc3\x00\x00\x00\x7f\x19\x00\x00\xa7\x19\x00\x00\xca\x19\x00\x00\xf2\x19\x00\x00\x35\x1a\x00\x00\x5a\x1a\x00\x00\xd3\x1a\x00\x00\x2f\x1b\x00\x00\x52\x1b\x00\x00\x75\x1b\x00\x00\x58\x0b\x00\x00\x93\x1b\x00\x00\xdd\x00\x00\x00\xbb\x06\x00\x00\xdc\x1b\x00\x00\xb6\x1a\x00\x00\x01\x1c\x00\x00\x20\x01\x00\x00\x71\x07\x00\x00\x4a\x1c\x00\x00\x6e\x1c\x00\x00\xf2\x07\x00\x00\x8f\x1c\x00\x00\x6e\x08\x00\x00\xa5\x1c\x00\x00\xe4\x08\x00\x00\xe6\x1c\x00\x00\x60\x09\x00\x00\xc4\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++alex_table :: AlexAddr+alex_table = AlexA#+  "\x00\x00\x64\x00\xbc\x00\xb5\x00\x6d\x00\xc8\x00\x5e\x00\x9d\x00\x6e\x00\x77\x00\x60\x00\x80\x00\x5e\x00\x5e\x00\x5e\x00\x7d\x00\x8b\x00\x8c\x00\x8e\x00\x5d\x00\x15\x00\x16\x00\x18\x00\x32\x00\x19\x00\x31\x00\x1f\x00\x25\x00\x7a\x00\x11\x00\x26\x00\x10\x00\x79\x00\x5e\x00\xc8\x00\xef\x00\xc9\x00\xc8\x00\xc8\x00\xc8\x00\xee\x00\xa5\x00\xa6\x00\xc8\x00\xc8\x00\xaa\x00\xc4\x00\xc8\x00\xc8\x00\xcf\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xcd\x00\xab\x00\xc8\x00\xc8\x00\xc8\x00\xca\x00\xc8\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xa8\x00\xc8\x00\xa9\x00\xc8\x00\xb6\x00\xac\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xae\x00\xc6\x00\xaf\x00\xc8\x00\x5e\x00\xd5\x00\xd5\x00\xff\xff\x60\x00\x76\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x12\x00\xff\xff\xff\xff\x60\x00\x6e\x00\x5e\x00\x5e\x00\x5e\x00\xff\xff\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x5e\x00\xd0\x00\xd0\x00\x78\x00\xff\xff\xff\xff\xff\xff\x64\x00\x20\x00\x5e\x00\x5e\x00\xff\xff\xff\xff\x0f\x00\x60\x00\x7c\x00\x5e\x00\x5e\x00\x5e\x00\x93\x00\x5c\x00\x4a\x00\x0f\x00\xff\xff\xff\xff\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x95\x00\x88\x00\x5e\x00\x5e\x00\x49\x00\x7e\x00\xbe\x00\x60\x00\x7c\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x4f\x00\x62\x00\x0f\x00\x60\x00\x7c\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x63\x00\x65\x00\x70\x00\x60\x00\xa2\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x91\x00\x8b\x00\x7e\x00\xbf\x00\xc0\x00\xc2\x00\x91\x00\xc0\x00\x5e\x00\xc3\x00\xe8\x00\x7e\x00\x0f\x00\xe9\x00\xea\x00\xeb\x00\xed\x00\x5e\x00\x00\x00\x00\x00\x5e\x00\x0f\x00\x00\x00\x00\x00\x60\x00\x0c\x00\x5e\x00\x5e\x00\x5e\x00\x1e\x00\x0f\x00\x00\x00\x00\x00\x27\x00\x0c\x00\xe1\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x5f\x00\x5e\x00\xd0\x00\xd0\x00\x61\x00\xff\xff\x5f\x00\x5f\x00\x5f\x00\x00\x00\x00\x00\x3d\x00\x91\x00\x00\x00\x0f\x00\x00\x00\x7b\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x5f\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x5e\x00\x5e\x00\x5e\x00\x1d\x00\x9e\x00\x5e\x00\x87\x00\x00\x00\x91\x00\x3d\x00\x7b\x00\x5e\x00\x5e\x00\x5e\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x7f\x00\x5e\x00\xe5\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x60\x00\x0c\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x00\x00\x0f\x00\xd5\x00\xd5\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x00\x00\x00\x00\x30\x00\x5e\x00\x00\x00\x00\x00\x1a\x00\x5f\x00\x30\x00\x30\x00\x30\x00\x0c\x00\xff\xff\x5f\x00\x5f\x00\x5f\x00\x0d\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\xbd\x00\xbb\x00\x5f\x00\x4a\x00\x5e\x00\x86\x00\x00\x00\x00\x00\x60\x00\x80\x00\x5e\x00\x5e\x00\x5e\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x5e\x00\x28\x00\x0c\x00\x1c\x00\x00\x00\x2f\x00\x2f\x00\x2f\x00\xa4\x00\xa6\x00\x00\x00\x00\x00\xaa\x00\x0e\x00\x00\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x00\x00\x2f\x00\xab\x00\x5a\x00\x2a\x00\x00\x00\x0c\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xa7\x00\x00\x00\xa9\x00\x29\x00\xbb\x00\xac\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xad\x00\x00\x00\xaf\x00\x81\x00\x81\x00\x81\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x23\x00\x12\x00\x12\x00\x12\x00\x12\x00\x23\x00\x23\x00\x23\x00\x23\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x30\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x59\x00\x00\x00\x23\x00\x8f\x00\x91\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x30\x00\x00\x00\x5b\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x91\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x83\x00\x83\x00\x83\x00\x91\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x13\x00\x13\x00\x13\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x00\x00\x00\x13\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x84\x00\x84\x00\x84\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x17\x00\x17\x00\x17\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x3c\x00\x00\x00\x17\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x2f\x00\x2f\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x23\x00\x23\x00\x23\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x90\x00\x91\x00\x00\x00\x23\x00\x00\x00\x00\x00\x1b\x00\x91\x00\x00\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x2c\x00\x2c\x00\x2c\x00\x4e\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x41\x00\x00\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x91\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x1d\x00\x2c\x00\x53\x00\x91\x00\x00\x00\x00\x00\x3d\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x35\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x35\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x6a\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x3a\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x40\x00\x00\x00\x40\x00\x00\x00\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\x00\x00\x45\x00\x00\x00\x45\x00\x00\x00\x3f\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\x00\x00\x42\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x44\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x47\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x35\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x4c\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x3a\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xb3\x00\xb1\x00\x00\x00\x4d\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\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\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb2\x00\xb0\x00\x4e\x00\xcb\x00\xb1\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\xcb\x00\x00\x00\xcb\x00\xb0\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\xcb\x00\xe6\x00\xcb\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\xff\xff\x00\x00\x00\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\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\x53\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x68\x00\x00\x00\x53\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x68\x00\x9c\x00\x54\x00\x54\x00\x54\x00\xec\x00\x00\x00\x00\x00\x54\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x69\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x69\x00\x9b\x00\x54\x00\x54\x00\x54\x00\xec\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x98\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x97\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x96\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x94\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x5a\x00\x8a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5b\x00\x85\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\xff\xff\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\x6c\x00\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x73\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x6c\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x89\x00\x6c\x00\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x89\x00\x89\x00\x00\x00\x6f\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x89\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x89\x00\x89\x00\xc8\x00\x6f\x00\x89\x00\x89\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\x71\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\x71\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\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\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x83\x00\x83\x00\x83\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x17\x00\x17\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x84\x00\x84\x00\x84\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x17\x00\x17\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5b\x00\x85\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x82\x00\x82\x00\x82\x00\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x88\x00\x88\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\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\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x5a\x00\x8a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x83\x00\x83\x00\x83\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x13\x00\x13\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x84\x00\x84\x00\x84\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\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\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\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\xa0\x00\xa0\x00\xa0\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\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa1\x00\xa1\x00\xa1\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x2c\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x56\x00\x58\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x57\x00\x54\x00\x54\x00\x54\x00\x55\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x92\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x45\x00\x00\x00\x00\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbc\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x00\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xbd\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x72\x00\xc8\x00\xc8\x00\xd4\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x2b\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x9f\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\x8e\x00\xc8\x00\xc8\x00\x99\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x9a\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xa1\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\xa3\x00\xc8\x00\xc8\x00\x00\x00\xc5\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\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\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xa1\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa0\x00\xc8\x00\xc8\x00\xc8\x00\xe4\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\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x3d\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xa0\x00\xcb\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x00\x00\xc8\x00\xcb\x00\xc8\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcc\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x00\x00\xcc\x00\xcc\x00\xcc\x00\xcc\x00\xcd\x00\x00\x00\x00\x00\xcc\x00\xcc\x00\x00\x00\xcc\x00\xcc\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcb\x00\xcc\x00\xcc\x00\xcc\x00\xcc\x00\xcc\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xcd\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\xcc\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\x00\x00\xcc\x00\x00\x00\xcc\x00\xcd\x00\x00\x00\xcd\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x50\x00\xcd\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x4c\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x41\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x4d\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x4a\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x47\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x48\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\xec\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x3d\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x3a\x00\x00\x00\x00\x00\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\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\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\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#++alex_check :: AlexAddr+alex_check = AlexA#+  "\xff\xff\x2d\x00\x01\x00\x02\x00\x2d\x00\x04\x00\x05\x00\x06\x00\x2d\x00\x65\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x65\x00\x7d\x00\x7d\x00\x7d\x00\x61\x00\x2d\x00\x2d\x00\x2d\x00\x69\x00\x6d\x00\x69\x00\x67\x00\x61\x00\x0a\x00\x6e\x00\x72\x00\x6e\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x05\x00\x30\x00\x31\x00\x0a\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x23\x00\x0a\x00\x0a\x00\x09\x00\x2d\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\x30\x00\x31\x00\x23\x00\x0a\x00\x0a\x00\x0a\x00\x2d\x00\x6c\x00\x20\x00\x05\x00\x0a\x00\x0a\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x7c\x00\x21\x00\x5f\x00\x2d\x00\x0a\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x7c\x00\x23\x00\x20\x00\x05\x00\x5f\x00\x23\x00\x23\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x5f\x00\x2d\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x2d\x00\x2d\x00\x2d\x00\x09\x00\x23\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x24\x00\x7d\x00\x23\x00\x23\x00\x23\x00\x23\x00\x2a\x00\x23\x00\x20\x00\x23\x00\x23\x00\x23\x00\x2d\x00\x23\x00\x23\x00\x23\x00\x23\x00\x20\x00\xff\xff\xff\xff\x05\x00\x2d\x00\xff\xff\xff\xff\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x6c\x00\x2d\x00\xff\xff\xff\xff\x70\x00\x7b\x00\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x05\x00\x20\x00\x30\x00\x31\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x45\x00\x5e\x00\xff\xff\x2d\x00\xff\xff\x7b\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x5f\x00\x7c\x00\x05\x00\x2d\x00\xff\xff\x7c\x00\x65\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x20\x00\x23\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x2d\x00\x30\x00\x31\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\x05\x00\x20\x00\xff\xff\xff\xff\x23\x00\x05\x00\x0b\x00\x0c\x00\x0d\x00\x7b\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x01\x00\x02\x00\x20\x00\x5f\x00\x05\x00\x7b\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x20\x00\x5f\x00\x7b\x00\x23\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\x2d\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x20\x00\x3b\x00\x22\x00\x5f\x00\xff\xff\x7b\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5f\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\x7d\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x05\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\x20\x00\x23\x00\x24\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x20\x00\xff\xff\x22\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x7c\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x2a\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x02\x00\x03\x00\x5f\x00\xff\xff\xff\xff\x07\x00\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x5e\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\x01\x00\x02\x00\x7c\x00\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x50\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x5f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x02\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\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\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\x5f\x00\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x23\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\x0a\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\x5e\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7c\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x23\x00\xff\xff\xff\xff\x07\x00\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\x5e\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7c\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x23\x00\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x04\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x45\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\x7c\x00\x7d\x00\x7e\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x02\x00\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x45\x00\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x04\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\xff\xff\x5e\x00\xff\xff\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x5f\x00\x7e\x00\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x78\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x78\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x23\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x45\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++alex_deflt :: AlexAddr+alex_deflt = AlexA#+  "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\xff\xff\x89\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x89\x00\x66\x00\x67\x00\x68\x00\x69\x00\x68\x00\x6b\x00\x6b\x00\x67\x00\x67\x00\x6b\x00\x67\x00\x6b\x00\x67\x00\x66\x00\x66\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x89\x00\x89\x00\x89\x00\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++alex_accept = listArray (0 :: Int, 239)+  [ AlexAccNone+  , AlexAcc 197+  , AlexAccNone+  , AlexAcc 196+  , AlexAcc 195+  , AlexAcc 194+  , AlexAcc 193+  , AlexAcc 192+  , AlexAcc 191+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccNone+  , AlexAccSkip+  , AlexAccSkip+  , AlexAcc 190+  , AlexAcc 189+  , AlexAccPred 188 ( isNormalComment )(AlexAccNone)+  , AlexAccPred 187 ( isNormalComment )(AlexAccNone)+  , AlexAccPred 186 ( isNormalComment )(AlexAccNone)+  , AlexAccPred 185 ( isNormalComment )(AlexAcc 184)+  , AlexAcc 183+  , AlexAcc 182+  , AlexAccPred 181 ( alexNotPred (ifExtension HaddockBit) )(AlexAccNone)+  , AlexAccPred 180 ( alexNotPred (ifExtension HaddockBit) )(AlexAcc 179)+  , AlexAccPred 178 ( alexNotPred (ifExtension HaddockBit) )(AlexAccPred 177 ( ifExtension HaddockBit )(AlexAccNone))+  , AlexAcc 176+  , AlexAccPred 175 ( atEOL )(AlexAccNone)+  , AlexAccPred 174 ( atEOL )(AlexAccNone)+  , AlexAccPred 173 ( atEOL )(AlexAccNone)+  , AlexAccPred 172 ( atEOL )(AlexAcc 171)+  , AlexAccPred 170 ( atEOL )(AlexAcc 169)+  , AlexAccPred 168 ( atEOL )(AlexAccPred 167 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 166 ( followedByOpeningToken )(AlexAccPred 165 ( precededByClosingToken )(AlexAcc 164))))+  , AlexAccPred 163 ( atEOL )(AlexAccPred 162 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 161 ( followedByOpeningToken )(AlexAccPred 160 ( precededByClosingToken )(AlexAcc 159))))+  , AlexAccPred 158 ( atEOL )(AlexAccNone)+  , AlexAccPred 157 ( atEOL )(AlexAccNone)+  , AlexAccPred 156 ( atEOL )(AlexAcc 155)+  , AlexAccSkip+  , AlexAccPred 154 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+  , AlexAccPred 153 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False) `alexAndPred`  followedByDigit )(AlexAccNone)+  , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+  , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+  , AlexAccPred 152 ( notFollowedBy '-' )(AlexAccNone)+  , AlexAccSkip+  , AlexAccPred 151 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+  , AlexAccPred 150 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)+  , AlexAccPred 149 ( notFollowedBySymbol )(AlexAccNone)+  , AlexAcc 148+  , AlexAccPred 147 ( known_pragma linePrags )(AlexAccNone)+  , AlexAccPred 146 ( known_pragma linePrags )(AlexAcc 145)+  , AlexAccPred 144 ( known_pragma linePrags )(AlexAccPred 143 ( known_pragma oneWordPrags )(AlexAccPred 142 ( known_pragma ignoredPrags )(AlexAccPred 141 ( known_pragma fileHeaderPrags )(AlexAccNone))))+  , AlexAccPred 140 ( known_pragma linePrags )(AlexAccPred 139 ( known_pragma oneWordPrags )(AlexAccPred 138 ( known_pragma ignoredPrags )(AlexAccPred 137 ( known_pragma fileHeaderPrags )(AlexAccNone))))+  , AlexAcc 136+  , AlexAcc 135+  , AlexAcc 134+  , AlexAcc 133+  , AlexAcc 132+  , AlexAcc 131+  , AlexAcc 130+  , AlexAcc 129+  , AlexAccPred 128 ( known_pragma twoWordPrags )(AlexAccNone)+  , AlexAcc 127+  , AlexAcc 126+  , AlexAcc 125+  , AlexAccPred 124 ( ifExtension HaddockBit )(AlexAccNone)+  , AlexAccPred 123 ( ifExtension ThQuotesBit )(AlexAccNone)+  , AlexAccPred 122 ( ifExtension ThQuotesBit )(AlexAccNone)+  , AlexAccPred 121 ( ifExtension ThQuotesBit )(AlexAccPred 120 ( ifExtension QqBit )(AlexAccNone))+  , AlexAccPred 119 ( ifExtension ThQuotesBit )(AlexAccNone)+  , AlexAccPred 118 ( ifExtension ThQuotesBit )(AlexAccPred 117 ( ifExtension QqBit )(AlexAccNone))+  , AlexAccPred 116 ( ifExtension ThQuotesBit )(AlexAccPred 115 ( ifExtension QqBit )(AlexAccNone))+  , AlexAccPred 114 ( ifExtension ThQuotesBit )(AlexAccPred 113 ( ifExtension QqBit )(AlexAccNone))+  , AlexAccPred 112 ( ifExtension ThQuotesBit )(AlexAccNone)+  , AlexAccPred 111 ( ifExtension ThQuotesBit )(AlexAccNone)+  , AlexAccPred 110 ( ifExtension QqBit )(AlexAccNone)+  , AlexAccPred 109 ( ifExtension QqBit )(AlexAccNone)+  , AlexAccPred 108 ( ifCurrentChar '⟦' `alexAndPred`+        ifExtension UnicodeSyntaxBit `alexAndPred`+        ifExtension ThQuotesBit )(AlexAccPred 107 ( ifCurrentChar '⟧' `alexAndPred`+        ifExtension UnicodeSyntaxBit `alexAndPred`+        ifExtension ThQuotesBit )(AlexAccPred 106 ( ifCurrentChar '⦇' `alexAndPred`+        ifExtension UnicodeSyntaxBit `alexAndPred`+        ifExtension ArrowsBit )(AlexAccPred 105 ( ifCurrentChar '⦈' `alexAndPred`+        ifExtension UnicodeSyntaxBit `alexAndPred`+        ifExtension ArrowsBit )(AlexAccNone))))+  , AlexAccPred 104 ( ifExtension ArrowsBit `alexAndPred`+        notFollowedBySymbol )(AlexAccNone)+  , AlexAccPred 103 ( ifExtension ArrowsBit )(AlexAccNone)+  , AlexAccPred 102 ( ifExtension IpBit )(AlexAccNone)+  , AlexAccPred 101 ( ifExtension OverloadedLabelsBit )(AlexAccNone)+  , AlexAccPred 100 ( ifExtension UnboxedTuplesBit `alexOrPred`+           ifExtension UnboxedSumsBit )(AlexAccNone)+  , AlexAccPred 99 ( ifExtension UnboxedTuplesBit `alexOrPred`+           ifExtension UnboxedSumsBit )(AlexAccNone)+  , AlexAcc 98+  , AlexAcc 97+  , AlexAcc 96+  , AlexAcc 95+  , AlexAcc 94+  , AlexAcc 93+  , AlexAcc 92+  , AlexAcc 91+  , AlexAcc 90+  , AlexAcc 89+  , AlexAcc 88+  , AlexAcc 87+  , AlexAcc 86+  , AlexAcc 85+  , AlexAcc 84+  , AlexAcc 83+  , AlexAcc 82+  , AlexAcc 81+  , AlexAcc 80+  , AlexAcc 79+  , AlexAcc 78+  , AlexAcc 77+  , AlexAcc 76+  , AlexAcc 75+  , AlexAcc 74+  , AlexAcc 73+  , AlexAccPred 72 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 71 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 70 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 69 ( ifExtension MagicHashBit )(AlexAccPred 68 ( ifExtension MagicHashBit )(AlexAccNone))+  , AlexAccPred 67 ( ifExtension MagicHashBit )(AlexAccPred 66 ( ifExtension MagicHashBit )(AlexAccNone))+  , AlexAccPred 65 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 64 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 63 ( followedByOpeningToken )(AlexAccPred 62 ( precededByClosingToken )(AlexAcc 61)))+  , AlexAccPred 60 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 59 ( followedByOpeningToken )(AlexAccPred 58 ( precededByClosingToken )(AlexAcc 57)))+  , AlexAccPred 56 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 55 ( followedByOpeningToken )(AlexAccPred 54 ( precededByClosingToken )(AlexAcc 53)))+  , AlexAccPred 52 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 51 ( followedByOpeningToken )(AlexAccPred 50 ( precededByClosingToken )(AlexAcc 49)))+  , AlexAccPred 48 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 47 ( followedByOpeningToken )(AlexAccPred 46 ( precededByClosingToken )(AlexAcc 45)))+  , AlexAccPred 44 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 43 ( followedByOpeningToken )(AlexAccPred 42 ( precededByClosingToken )(AlexAcc 41)))+  , AlexAccPred 40 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 39 ( followedByOpeningToken )(AlexAccPred 38 ( precededByClosingToken )(AlexAcc 37)))+  , AlexAcc 36+  , AlexAcc 35+  , AlexAcc 34+  , AlexAcc 33+  , AlexAcc 32+  , AlexAccPred 31 ( ifExtension BinaryLiteralsBit )(AlexAccNone)+  , AlexAcc 30+  , AlexAcc 29+  , AlexAccPred 28 ( ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 27 ( ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 26 ( ifExtension NegativeLiteralsBit `alexAndPred`+                                           ifExtension BinaryLiteralsBit )(AlexAccNone)+  , AlexAccPred 25 ( ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 24 ( ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAcc 23+  , AlexAcc 22+  , AlexAccPred 21 ( ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 20 ( ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 19 ( ifExtension HexFloatLiteralsBit )(AlexAccNone)+  , AlexAccPred 18 ( ifExtension HexFloatLiteralsBit )(AlexAccNone)+  , AlexAccPred 17 ( ifExtension HexFloatLiteralsBit `alexAndPred`+                                           ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 16 ( ifExtension HexFloatLiteralsBit `alexAndPred`+                                           ifExtension NegativeLiteralsBit )(AlexAccNone)+  , AlexAccPred 15 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 14 ( ifExtension MagicHashBit `alexAndPred`+                                           ifExtension BinaryLiteralsBit )(AlexAccNone)+  , AlexAccPred 13 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 12 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 11 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 10 ( ifExtension MagicHashBit `alexAndPred`+                                           ifExtension BinaryLiteralsBit )(AlexAccNone)+  , AlexAccPred 9 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 8 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 7 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 6 ( ifExtension MagicHashBit `alexAndPred`+                                           ifExtension BinaryLiteralsBit )(AlexAccNone)+  , AlexAccPred 5 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 4 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 3 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAccPred 2 ( ifExtension MagicHashBit )(AlexAccNone)+  , AlexAcc 1+  , AlexAcc 0+  ]++alex_actions = array (0 :: Int, 198)+  [ (197,alex_action_14)+  , (196,alex_action_20)+  , (195,alex_action_21)+  , (194,alex_action_19)+  , (193,alex_action_22)+  , (192,alex_action_26)+  , (191,alex_action_27)+  , (190,alex_action_1)+  , (189,alex_action_1)+  , (188,alex_action_2)+  , (187,alex_action_2)+  , (186,alex_action_2)+  , (185,alex_action_2)+  , (184,alex_action_27)+  , (183,alex_action_3)+  , (182,alex_action_4)+  , (181,alex_action_5)+  , (180,alex_action_5)+  , (179,alex_action_27)+  , (178,alex_action_5)+  , (177,alex_action_38)+  , (176,alex_action_6)+  , (175,alex_action_7)+  , (174,alex_action_7)+  , (173,alex_action_7)+  , (172,alex_action_7)+  , (171,alex_action_27)+  , (170,alex_action_7)+  , (169,alex_action_27)+  , (168,alex_action_7)+  , (167,alex_action_78)+  , (166,alex_action_79)+  , (165,alex_action_80)+  , (164,alex_action_81)+  , (163,alex_action_7)+  , (162,alex_action_78)+  , (161,alex_action_79)+  , (160,alex_action_80)+  , (159,alex_action_81)+  , (158,alex_action_8)+  , (157,alex_action_8)+  , (156,alex_action_8)+  , (155,alex_action_27)+  , (154,alex_action_10)+  , (153,alex_action_11)+  , (152,alex_action_15)+  , (151,alex_action_17)+  , (150,alex_action_17)+  , (149,alex_action_18)+  , (148,alex_action_23)+  , (147,alex_action_24)+  , (146,alex_action_24)+  , (145,alex_action_27)+  , (144,alex_action_24)+  , (143,alex_action_32)+  , (142,alex_action_33)+  , (141,alex_action_35)+  , (140,alex_action_24)+  , (139,alex_action_32)+  , (138,alex_action_33)+  , (137,alex_action_36)+  , (136,alex_action_25)+  , (135,alex_action_27)+  , (134,alex_action_27)+  , (133,alex_action_27)+  , (132,alex_action_27)+  , (131,alex_action_28)+  , (130,alex_action_29)+  , (129,alex_action_30)+  , (128,alex_action_31)+  , (127,alex_action_34)+  , (126,alex_action_37)+  , (125,alex_action_37)+  , (124,alex_action_39)+  , (123,alex_action_40)+  , (122,alex_action_41)+  , (121,alex_action_42)+  , (120,alex_action_49)+  , (119,alex_action_43)+  , (118,alex_action_44)+  , (117,alex_action_49)+  , (116,alex_action_45)+  , (115,alex_action_49)+  , (114,alex_action_46)+  , (113,alex_action_49)+  , (112,alex_action_47)+  , (111,alex_action_48)+  , (110,alex_action_49)+  , (109,alex_action_50)+  , (108,alex_action_51)+  , (107,alex_action_52)+  , (106,alex_action_55)+  , (105,alex_action_56)+  , (104,alex_action_53)+  , (103,alex_action_54)+  , (102,alex_action_57)+  , (101,alex_action_58)+  , (100,alex_action_59)+  , (99,alex_action_60)+  , (98,alex_action_61)+  , (97,alex_action_61)+  , (96,alex_action_62)+  , (95,alex_action_63)+  , (94,alex_action_63)+  , (93,alex_action_64)+  , (92,alex_action_65)+  , (91,alex_action_66)+  , (90,alex_action_67)+  , (89,alex_action_68)+  , (88,alex_action_68)+  , (87,alex_action_69)+  , (86,alex_action_70)+  , (85,alex_action_70)+  , (84,alex_action_71)+  , (83,alex_action_71)+  , (82,alex_action_72)+  , (81,alex_action_72)+  , (80,alex_action_72)+  , (79,alex_action_72)+  , (78,alex_action_72)+  , (77,alex_action_72)+  , (76,alex_action_72)+  , (75,alex_action_72)+  , (74,alex_action_73)+  , (73,alex_action_73)+  , (72,alex_action_74)+  , (71,alex_action_75)+  , (70,alex_action_76)+  , (69,alex_action_76)+  , (68,alex_action_109)+  , (67,alex_action_76)+  , (66,alex_action_110)+  , (65,alex_action_77)+  , (64,alex_action_78)+  , (63,alex_action_79)+  , (62,alex_action_80)+  , (61,alex_action_81)+  , (60,alex_action_78)+  , (59,alex_action_79)+  , (58,alex_action_80)+  , (57,alex_action_81)+  , (56,alex_action_78)+  , (55,alex_action_79)+  , (54,alex_action_80)+  , (53,alex_action_81)+  , (52,alex_action_78)+  , (51,alex_action_79)+  , (50,alex_action_80)+  , (49,alex_action_81)+  , (48,alex_action_78)+  , (47,alex_action_79)+  , (46,alex_action_80)+  , (45,alex_action_81)+  , (44,alex_action_78)+  , (43,alex_action_79)+  , (42,alex_action_80)+  , (41,alex_action_81)+  , (40,alex_action_78)+  , (39,alex_action_79)+  , (38,alex_action_80)+  , (37,alex_action_81)+  , (36,alex_action_82)+  , (35,alex_action_83)+  , (34,alex_action_84)+  , (33,alex_action_85)+  , (32,alex_action_85)+  , (31,alex_action_86)+  , (30,alex_action_87)+  , (29,alex_action_88)+  , (28,alex_action_89)+  , (27,alex_action_89)+  , (26,alex_action_90)+  , (25,alex_action_91)+  , (24,alex_action_92)+  , (23,alex_action_93)+  , (22,alex_action_93)+  , (21,alex_action_94)+  , (20,alex_action_94)+  , (19,alex_action_95)+  , (18,alex_action_95)+  , (17,alex_action_96)+  , (16,alex_action_96)+  , (15,alex_action_97)+  , (14,alex_action_98)+  , (13,alex_action_99)+  , (12,alex_action_100)+  , (11,alex_action_101)+  , (10,alex_action_102)+  , (9,alex_action_103)+  , (8,alex_action_104)+  , (7,alex_action_105)+  , (6,alex_action_106)+  , (5,alex_action_107)+  , (4,alex_action_108)+  , (3,alex_action_109)+  , (2,alex_action_110)+  , (1,alex_action_111)+  , (0,alex_action_112)+  ]++{-# LINE 660 "compiler/GHC/Parser/Lexer.x" #-}+++-- -----------------------------------------------------------------------------+-- The token type++data Token+  = ITas                        -- Haskell keywords+  | ITcase+  | ITclass+  | ITdata+  | ITdefault+  | ITderiving+  | ITdo+  | ITelse+  | IThiding+  | ITforeign+  | ITif+  | ITimport+  | ITin+  | ITinfix+  | ITinfixl+  | ITinfixr+  | ITinstance+  | ITlet+  | ITmodule+  | ITnewtype+  | ITof+  | ITqualified+  | ITthen+  | ITtype+  | ITwhere++  | ITforall            IsUnicodeSyntax -- GHC extension keywords+  | ITexport+  | ITlabel+  | ITdynamic+  | ITsafe+  | ITinterruptible+  | ITunsafe+  | ITstdcallconv+  | ITccallconv+  | ITcapiconv+  | ITprimcallconv+  | ITjavascriptcallconv+  | ITmdo+  | ITfamily+  | ITrole+  | ITgroup+  | ITby+  | ITusing+  | ITpattern+  | ITstatic+  | ITstock+  | ITanyclass+  | ITvia++  -- Backpack tokens+  | ITunit+  | ITsignature+  | ITdependency+  | ITrequires++  -- Pragmas, see  note [Pragma source text] in BasicTypes+  | ITinline_prag       SourceText InlineSpec RuleMatchInfo+  | ITspec_prag         SourceText                -- SPECIALISE+  | ITspec_inline_prag  SourceText Bool    -- SPECIALISE INLINE (or NOINLINE)+  | ITsource_prag       SourceText+  | ITrules_prag        SourceText+  | ITwarning_prag      SourceText+  | ITdeprecated_prag   SourceText+  | ITline_prag         SourceText  -- not usually produced, see 'UsePosPragsBit'+  | ITcolumn_prag       SourceText  -- not usually produced, see 'UsePosPragsBit'+  | ITscc_prag          SourceText+  | ITgenerated_prag    SourceText+  | ITcore_prag         SourceText         -- hdaume: core annotations+  | ITunpack_prag       SourceText+  | ITnounpack_prag     SourceText+  | ITann_prag          SourceText+  | ITcomplete_prag     SourceText+  | ITclose_prag+  | IToptions_prag String+  | ITinclude_prag String+  | ITlanguage_prag+  | ITminimal_prag      SourceText+  | IToverlappable_prag SourceText  -- instance overlap mode+  | IToverlapping_prag  SourceText  -- instance overlap mode+  | IToverlaps_prag     SourceText  -- instance overlap mode+  | ITincoherent_prag   SourceText  -- instance overlap mode+  | ITctype             SourceText+  | ITcomment_line_prag         -- See Note [Nested comment line pragmas]++  | ITdotdot                    -- reserved symbols+  | ITcolon+  | ITdcolon            IsUnicodeSyntax+  | ITequal+  | ITlam+  | ITlcase+  | ITvbar+  | ITlarrow            IsUnicodeSyntax+  | ITrarrow            IsUnicodeSyntax+  | ITdarrow            IsUnicodeSyntax+  | ITminus+  | ITbang     -- Prefix (!) only, e.g. f !x = rhs+  | ITtilde    -- Prefix (~) only, e.g. f ~x = rhs+  | ITat       -- Tight infix (@) only, e.g. f x@pat = rhs+  | ITtypeApp  -- Prefix (@) only, e.g. f @t+  | ITstar              IsUnicodeSyntax+  | ITdot++  | ITbiglam                    -- GHC-extension symbols++  | ITocurly                    -- special symbols+  | ITccurly+  | ITvocurly+  | ITvccurly+  | ITobrack+  | ITopabrack                  -- [:, for parallel arrays with -XParallelArrays+  | ITcpabrack                  -- :], for parallel arrays with -XParallelArrays+  | ITcbrack+  | IToparen+  | ITcparen+  | IToubxparen+  | ITcubxparen+  | ITsemi+  | ITcomma+  | ITunderscore+  | ITbackquote+  | ITsimpleQuote               --  '++  | ITvarid   FastString        -- identifiers+  | ITconid   FastString+  | ITvarsym  FastString+  | ITconsym  FastString+  | ITqvarid  (FastString,FastString)+  | ITqconid  (FastString,FastString)+  | ITqvarsym (FastString,FastString)+  | ITqconsym (FastString,FastString)++  | ITdupipvarid   FastString   -- GHC extension: implicit param: ?x+  | ITlabelvarid   FastString   -- Overloaded label: #x++  | ITchar     SourceText Char       -- Note [Literal source text] in BasicTypes+  | ITstring   SourceText FastString -- Note [Literal source text] in BasicTypes+  | ITinteger  IntegralLit           -- Note [Literal source text] in BasicTypes+  | ITrational FractionalLit++  | ITprimchar   SourceText Char     -- Note [Literal source text] in BasicTypes+  | ITprimstring SourceText ByteString -- Note [Literal source text] @BasicTypes+  | ITprimint    SourceText Integer  -- Note [Literal source text] in BasicTypes+  | ITprimword   SourceText Integer  -- Note [Literal source text] in BasicTypes+  | ITprimfloat  FractionalLit+  | ITprimdouble FractionalLit++  -- Template Haskell extension tokens+  | ITopenExpQuote HasE IsUnicodeSyntax --  [| or [e|+  | ITopenPatQuote                      --  [p|+  | ITopenDecQuote                      --  [d|+  | ITopenTypQuote                      --  [t|+  | ITcloseQuote IsUnicodeSyntax        --  |]+  | ITopenTExpQuote HasE                --  [|| or [e||+  | ITcloseTExpQuote                    --  ||]+  | ITdollar                            --  prefix $+  | ITdollardollar                      --  prefix $$+  | ITtyQuote                           --  ''+  | ITquasiQuote (FastString,FastString,PsSpan)+    -- ITquasiQuote(quoter, quote, loc)+    -- represents a quasi-quote of the form+    -- [quoter| quote |]+  | ITqQuasiQuote (FastString,FastString,FastString,PsSpan)+    -- ITqQuasiQuote(Qual, quoter, quote, loc)+    -- represents a qualified quasi-quote of the form+    -- [Qual.quoter| quote |]++  -- Arrow notation extension+  | ITproc+  | ITrec+  | IToparenbar  IsUnicodeSyntax -- ^ @(|@+  | ITcparenbar  IsUnicodeSyntax -- ^ @|)@+  | ITlarrowtail IsUnicodeSyntax -- ^ @-<@+  | ITrarrowtail IsUnicodeSyntax -- ^ @>-@+  | ITLarrowtail IsUnicodeSyntax -- ^ @-<<@+  | ITRarrowtail IsUnicodeSyntax -- ^ @>>-@++  | ITunknown String             -- ^ Used when the lexer can't make sense of it+  | ITeof                        -- ^ end of file token++  -- Documentation annotations+  | ITdocCommentNext  String     -- ^ something beginning @-- |@+  | ITdocCommentPrev  String     -- ^ something beginning @-- ^@+  | ITdocCommentNamed String     -- ^ something beginning @-- $@+  | ITdocSection      Int String -- ^ a section heading+  | ITdocOptions      String     -- ^ doc options (prune, ignore-exports, etc)+  | ITlineComment     String     -- ^ comment starting by "--"+  | ITblockComment    String     -- ^ comment in {- -}++  deriving Show++instance Outputable Token where+  ppr x = text (show x)+++-- the bitmap provided as the third component indicates whether the+-- corresponding extension keyword is valid under the extension options+-- provided to the compiler; if the extension corresponding to *any* of the+-- bits set in the bitmap is enabled, the keyword is valid (this setup+-- facilitates using a keyword in two different extensions that can be+-- activated independently)+--+reservedWordsFM :: UniqFM (Token, ExtsBitmap)+reservedWordsFM = listToUFM $+    map (\(x, y, z) -> (mkFastString x, (y, z)))+        [( "_",              ITunderscore,    0 ),+         ( "as",             ITas,            0 ),+         ( "case",           ITcase,          0 ),+         ( "class",          ITclass,         0 ),+         ( "data",           ITdata,          0 ),+         ( "default",        ITdefault,       0 ),+         ( "deriving",       ITderiving,      0 ),+         ( "do",             ITdo,            0 ),+         ( "else",           ITelse,          0 ),+         ( "hiding",         IThiding,        0 ),+         ( "if",             ITif,            0 ),+         ( "import",         ITimport,        0 ),+         ( "in",             ITin,            0 ),+         ( "infix",          ITinfix,         0 ),+         ( "infixl",         ITinfixl,        0 ),+         ( "infixr",         ITinfixr,        0 ),+         ( "instance",       ITinstance,      0 ),+         ( "let",            ITlet,           0 ),+         ( "module",         ITmodule,        0 ),+         ( "newtype",        ITnewtype,       0 ),+         ( "of",             ITof,            0 ),+         ( "qualified",      ITqualified,     0 ),+         ( "then",           ITthen,          0 ),+         ( "type",           ITtype,          0 ),+         ( "where",          ITwhere,         0 ),++         ( "forall",         ITforall NormalSyntax, 0),+         ( "mdo",            ITmdo,           xbit RecursiveDoBit),+             -- See Note [Lexing type pseudo-keywords]+         ( "family",         ITfamily,        0 ),+         ( "role",           ITrole,          0 ),+         ( "pattern",        ITpattern,       xbit PatternSynonymsBit),+         ( "static",         ITstatic,        xbit StaticPointersBit ),+         ( "stock",          ITstock,         0 ),+         ( "anyclass",       ITanyclass,      0 ),+         ( "via",            ITvia,           0 ),+         ( "group",          ITgroup,         xbit TransformComprehensionsBit),+         ( "by",             ITby,            xbit TransformComprehensionsBit),+         ( "using",          ITusing,         xbit TransformComprehensionsBit),++         ( "foreign",        ITforeign,       xbit FfiBit),+         ( "export",         ITexport,        xbit FfiBit),+         ( "label",          ITlabel,         xbit FfiBit),+         ( "dynamic",        ITdynamic,       xbit FfiBit),+         ( "safe",           ITsafe,          xbit FfiBit .|.+                                              xbit SafeHaskellBit),+         ( "interruptible",  ITinterruptible, xbit InterruptibleFfiBit),+         ( "unsafe",         ITunsafe,        xbit FfiBit),+         ( "stdcall",        ITstdcallconv,   xbit FfiBit),+         ( "ccall",          ITccallconv,     xbit FfiBit),+         ( "capi",           ITcapiconv,      xbit CApiFfiBit),+         ( "prim",           ITprimcallconv,  xbit FfiBit),+         ( "javascript",     ITjavascriptcallconv, xbit FfiBit),++         ( "unit",           ITunit,          0 ),+         ( "dependency",     ITdependency,       0 ),+         ( "signature",      ITsignature,     0 ),++         ( "rec",            ITrec,           xbit ArrowsBit .|.+                                              xbit RecursiveDoBit),+         ( "proc",           ITproc,          xbit ArrowsBit)+     ]++{-----------------------------------+Note [Lexing type pseudo-keywords]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++One might think that we wish to treat 'family' and 'role' as regular old+varids whenever -XTypeFamilies and -XRoleAnnotations are off, respectively.+But, there is no need to do so. These pseudo-keywords are not stolen syntax:+they are only used after the keyword 'type' at the top-level, where varids are+not allowed. Furthermore, checks further downstream (GHC.Tc.TyCl) ensure that+type families and role annotations are never declared without their extensions+on. In fact, by unconditionally lexing these pseudo-keywords as special, we+can get better error messages.++Also, note that these are included in the `varid` production in the parser --+a key detail to make all this work.+-------------------------------------}++reservedSymsFM :: UniqFM (Token, IsUnicodeSyntax, ExtsBitmap)+reservedSymsFM = listToUFM $+    map (\ (x,w,y,z) -> (mkFastString x,(w,y,z)))+      [ ("..",  ITdotdot,                   NormalSyntax,  0 )+        -- (:) is a reserved op, meaning only list cons+       ,(":",   ITcolon,                    NormalSyntax,  0 )+       ,("::",  ITdcolon NormalSyntax,      NormalSyntax,  0 )+       ,("=",   ITequal,                    NormalSyntax,  0 )+       ,("\\",  ITlam,                      NormalSyntax,  0 )+       ,("|",   ITvbar,                     NormalSyntax,  0 )+       ,("<-",  ITlarrow NormalSyntax,      NormalSyntax,  0 )+       ,("->",  ITrarrow NormalSyntax,      NormalSyntax,  0 )+       ,("=>",  ITdarrow NormalSyntax,      NormalSyntax,  0 )+       ,("-",   ITminus,                    NormalSyntax,  0 )++       ,("*",   ITstar NormalSyntax,        NormalSyntax,  xbit StarIsTypeBit)++        -- For 'forall a . t'+       ,(".",   ITdot,                      NormalSyntax,  0 )++       ,("-<",  ITlarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)+       ,(">-",  ITrarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)+       ,("-<<", ITLarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)+       ,(">>-", ITRarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)++       ,("∷",   ITdcolon UnicodeSyntax,     UnicodeSyntax, 0 )+       ,("⇒",   ITdarrow UnicodeSyntax,     UnicodeSyntax, 0 )+       ,("∀",   ITforall UnicodeSyntax,     UnicodeSyntax, 0 )+       ,("→",   ITrarrow UnicodeSyntax,     UnicodeSyntax, 0 )+       ,("←",   ITlarrow UnicodeSyntax,     UnicodeSyntax, 0 )++       ,("⤙",   ITlarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)+       ,("⤚",   ITrarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)+       ,("⤛",   ITLarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)+       ,("⤜",   ITRarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)++       ,("★",   ITstar UnicodeSyntax,       UnicodeSyntax, xbit StarIsTypeBit)++        -- ToDo: ideally, → and ∷ should be "specials", so that they cannot+        -- form part of a large operator.  This would let us have a better+        -- syntax for kinds: ɑ∷*→* would be a legal kind signature. (maybe).+       ]++-- -----------------------------------------------------------------------------+-- Lexer actions++type Action = PsSpan -> StringBuffer -> Int -> P (PsLocated Token)++special :: Token -> Action+special tok span _buf _len = return (L span tok)++token, layout_token :: Token -> Action+token t span _buf _len = return (L span t)+layout_token t span _buf _len = pushLexState layout >> return (L span t)++idtoken :: (StringBuffer -> Int -> Token) -> Action+idtoken f span buf len = return (L span $! (f buf len))++skip_one_varid :: (FastString -> Token) -> Action+skip_one_varid f span buf len+  = return (L span $! f (lexemeToFastString (stepOn buf) (len-1)))++skip_two_varid :: (FastString -> Token) -> Action+skip_two_varid f span buf len+  = return (L span $! f (lexemeToFastString (stepOn (stepOn buf)) (len-2)))++strtoken :: (String -> Token) -> Action+strtoken f span buf len =+  return (L span $! (f $! lexemeToString buf len))++begin :: Int -> Action+begin code _span _str _len = do pushLexState code; lexToken++pop :: Action+pop _span _buf _len = do _ <- popLexState+                         lexToken+-- See Note [Nested comment line pragmas]+failLinePrag1 :: Action+failLinePrag1 span _buf _len = do+  b <- getBit InNestedCommentBit+  if b then return (L span ITcomment_line_prag)+       else lexError "lexical error in pragma"++-- See Note [Nested comment line pragmas]+popLinePrag1 :: Action+popLinePrag1 span _buf _len = do+  b <- getBit InNestedCommentBit+  if b then return (L span ITcomment_line_prag) else do+    _ <- popLexState+    lexToken++hopefully_open_brace :: Action+hopefully_open_brace span buf len+ = do relaxed <- getBit RelaxedLayoutBit+      ctx <- getContext+      (AI l _) <- getInput+      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 (mkSrcSpanPs span) (text "Missing block")++pop_and :: Action -> Action+pop_and act span buf len = do _ <- popLexState+                              act span buf len++-- See Note [Whitespace-sensitive operator parsing]+followedByOpeningToken :: AlexAccPred ExtsBitmap+followedByOpeningToken _ _ _ (AI _ buf)+  | atEnd buf = False+  | otherwise =+      case nextChar buf of+        ('{', buf') -> nextCharIsNot buf' (== '-')+        ('(', _) -> True+        ('[', _) -> True+        ('\"', _) -> True+        ('\'', _) -> True+        ('_', _) -> True+        (c, _) -> isAlphaNum c++-- See Note [Whitespace-sensitive operator parsing]+precededByClosingToken :: AlexAccPred ExtsBitmap+precededByClosingToken _ (AI _ buf) _ _ =+  case prevChar buf '\n' of+    '}' -> decodePrevNChars 1 buf /= "-"+    ')' -> True+    ']' -> True+    '\"' -> True+    '\'' -> True+    '_' -> True+    c -> isAlphaNum c++{-# INLINE nextCharIs #-}+nextCharIs :: StringBuffer -> (Char -> Bool) -> Bool+nextCharIs buf p = not (atEnd buf) && p (currentChar buf)++{-# INLINE nextCharIsNot #-}+nextCharIsNot :: StringBuffer -> (Char -> Bool) -> Bool+nextCharIsNot buf p = not (nextCharIs buf p)++notFollowedBy :: Char -> AlexAccPred ExtsBitmap+notFollowedBy char _ _ _ (AI _ buf)+  = nextCharIsNot buf (== char)++notFollowedBySymbol :: AlexAccPred ExtsBitmap+notFollowedBySymbol _ _ _ (AI _ buf)+  = nextCharIsNot buf (`elem` "!#$%&*+./<=>?@\\^|-~")++followedByDigit :: AlexAccPred ExtsBitmap+followedByDigit _ _ _ (AI _ buf)+  = afterOptionalSpace buf (\b -> nextCharIs b (`elem` ['0'..'9']))++ifCurrentChar :: Char -> AlexAccPred ExtsBitmap+ifCurrentChar char _ (AI _ buf) _ _+  = nextCharIs buf (== char)++-- We must reject doc comments as being ordinary comments everywhere.+-- In some cases the doc comment will be selected as the lexeme due to+-- maximal munch, but not always, because the nested comment rule is+-- valid in all states, but the doc-comment rules are only valid in+-- the non-layout states.+isNormalComment :: AlexAccPred ExtsBitmap+isNormalComment bits _ _ (AI _ buf)+  | HaddockBit `xtest` bits = notFollowedByDocOrPragma+  | otherwise               = nextCharIsNot buf (== '#')+  where+    notFollowedByDocOrPragma+       = afterOptionalSpace buf (\b -> nextCharIsNot b (`elem` "|^*$#"))++afterOptionalSpace :: StringBuffer -> (StringBuffer -> Bool) -> Bool+afterOptionalSpace buf p+    = if nextCharIs buf (== ' ')+      then p (snd (nextChar buf))+      else p buf++atEOL :: AlexAccPred ExtsBitmap+atEOL _ _ _ (AI _ buf) = atEnd buf || currentChar buf == '\n'++ifExtension :: ExtBits -> AlexAccPred ExtsBitmap+ifExtension extBits bits _ _ _ = extBits `xtest` bits++alexNotPred p userState in1 len in2+  = not (p userState in1 len in2)++alexOrPred p1 p2 userState in1 len in2+  = p1 userState in1 len in2 || p2 userState in1 len in2++multiline_doc_comment :: Action+multiline_doc_comment span buf _len = withLexedDocType (worker "")+  where+    worker commentAcc input docType checkNextLine = case alexGetChar' input of+      Just ('\n', input')+        | checkNextLine -> case checkIfCommentLine input' of+          Just input -> worker ('\n':commentAcc) input docType checkNextLine+          Nothing -> docCommentEnd input commentAcc docType buf span+        | otherwise -> docCommentEnd input commentAcc docType buf span+      Just (c, input) -> worker (c:commentAcc) input docType checkNextLine+      Nothing -> docCommentEnd input commentAcc docType buf span++    -- Check if the next line of input belongs to this doc comment as well.+    -- A doc comment continues onto the next line when the following+    -- conditions are met:+    --   * The line starts with "--"+    --   * The line doesn't start with "---".+    --   * The line doesn't start with "-- $", because that would be the+    --     start of a /new/ named haddock chunk (#10398).+    checkIfCommentLine :: AlexInput -> Maybe AlexInput+    checkIfCommentLine input = check (dropNonNewlineSpace input)+      where+        check input = do+          ('-', input) <- alexGetChar' input+          ('-', input) <- alexGetChar' input+          (c, after_c) <- alexGetChar' input+          case c of+            '-' -> Nothing+            ' ' -> case alexGetChar' after_c of+                     Just ('$', _) -> Nothing+                     _ -> Just input+            _   -> Just input++        dropNonNewlineSpace input = case alexGetChar' input of+          Just (c, input')+            | isSpace c && c /= '\n' -> dropNonNewlineSpace input'+            | otherwise -> input+          Nothing -> input++lineCommentToken :: Action+lineCommentToken span buf len = do+  b <- getBit RawTokenStreamBit+  if b then strtoken ITlineComment span buf len else lexToken++{-+  nested comments require traversing by hand, they can't be parsed+  using regular expressions.+-}+nested_comment :: P (PsLocated Token) -> Action+nested_comment cont span buf len = do+  input <- getInput+  go (reverse $ lexemeToString buf len) (1::Int) input+  where+    go commentAcc 0 input = do+      setInput input+      b <- getBit RawTokenStreamBit+      if b+        then docCommentEnd input commentAcc ITblockComment buf span+        else cont+    go commentAcc n input = case alexGetChar' input of+      Nothing -> errBrace input (psRealSpan span)+      Just ('-',input) -> case alexGetChar' input of+        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 (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 (psRealSpan span)+        Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input+                           go (parsedAcc ++ '\n':commentAcc) n input+        Just (_,_)   -> go ('\n':commentAcc) n input+      Just (c,input) -> go (c:commentAcc) n input++nested_doc_comment :: Action+nested_doc_comment span buf _len = withLexedDocType (go "")+  where+    go commentAcc input docType _ = case alexGetChar' input of+      Nothing -> errBrace input (psRealSpan span)+      Just ('-',input) -> case alexGetChar' input of+        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 (psRealSpan span)+        Just ('-',input) -> do+          setInput input+          let cont = do input <- getInput; go commentAcc input docType False+          nested_comment cont span buf _len+        Just (_,_) -> go ('\123':commentAcc) input docType False+      -- See Note [Nested comment line pragmas]+      Just ('\n',input) -> case alexGetChar' input of+        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+      Just (c,input) -> go (c:commentAcc) input docType False++-- See Note [Nested comment line pragmas]+parseNestedPragma :: AlexInput -> P (String,AlexInput)+parseNestedPragma input@(AI _ buf) = do+  origInput <- getInput+  setInput input+  setExts (.|. xbit InNestedCommentBit)+  pushLexState bol+  lt <- lexToken+  _ <- popLexState+  setExts (.&. complement (xbit InNestedCommentBit))+  postInput@(AI _ postBuf) <- getInput+  setInput origInput+  case unLoc lt of+    ITcomment_line_prag -> do+      let bytes = byteDiff buf postBuf+          diff  = lexemeToString buf bytes+      return (reverse diff, postInput)+    lt' -> panic ("parseNestedPragma: unexpected token" ++ (show lt'))++{-+Note [Nested comment line pragmas]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We used to ignore cpp-preprocessor-generated #line pragmas if they were inside+nested comments.++Now, when parsing a nested comment, if we encounter a line starting with '#' we+call parseNestedPragma, which executes the following:+1. Save the current lexer input (loc, buf) for later+2. Set the current lexer input to the beginning of the line starting with '#'+3. Turn the 'InNestedComment' extension on+4. Push the 'bol' lexer state+5. Lex a token. Due to (2), (3), and (4), this should always lex a single line+   or less and return the ITcomment_line_prag token. This may set source line+   and file location if a #line pragma is successfully parsed+6. Restore lexer input and state to what they were before we did all this+7. Return control to the function parsing a nested comment, informing it of+   what the lexer parsed++Regarding (5) above:+Every exit from the 'bol' lexer state (do_bol, popLinePrag1, failLinePrag1)+checks if the 'InNestedComment' extension is set. If it is, that function will+return control to parseNestedPragma by returning the ITcomment_line_prag token.++See #314 for more background on the bug this fixes.+-}++withLexedDocType :: (AlexInput -> (String -> Token) -> Bool -> P (PsLocated Token))+                 -> P (PsLocated Token)+withLexedDocType lexDocComment = do+  input@(AI _ buf) <- getInput+  case prevChar buf ' ' of+    -- The `Bool` argument to lexDocComment signals whether or not the next+    -- line of input might also belong to this doc comment.+    '|' -> lexDocComment input ITdocCommentNext True+    '^' -> lexDocComment input ITdocCommentPrev True+    '$' -> lexDocComment input ITdocCommentNamed True+    '*' -> lexDocSection 1 input+    _ -> panic "withLexedDocType: Bad doc type"+ where+    lexDocSection n input = case alexGetChar' input of+      Just ('*', input) -> lexDocSection (n+1) input+      Just (_,   _)     -> lexDocComment input (ITdocSection n) False+      Nothing -> do setInput input; lexToken -- eof reached, lex it normally++-- RULES pragmas turn on the forall and '.' keywords, and we turn them+-- off again at the end of the pragma.+rulePrag :: Action+rulePrag span buf len = do+  setExts (.|. xbit InRulePragBit)+  let !src = lexemeToString buf len+  return (L span (ITrules_prag (SourceText src)))++-- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+linePrag :: Action+linePrag span buf len = do+  usePosPrags <- getBit UsePosPragsBit+  if usePosPrags+    then begin line_prag2 span buf len+    else let !src = lexemeToString buf len+         in return (L span (ITline_prag (SourceText src)))++-- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+columnPrag :: Action+columnPrag span buf len = do+  usePosPrags <- getBit UsePosPragsBit+  let !src = lexemeToString buf len+  if usePosPrags+    then begin column_prag span buf len+    else let !src = lexemeToString buf len+         in return (L span (ITcolumn_prag (SourceText src)))++endPrag :: Action+endPrag span _buf _len = do+  setExts (.&. complement (xbit InRulePragBit))+  return (L span ITclose_prag)++-- docCommentEnd+-------------------------------------------------------------------------------+-- This function is quite tricky. We can't just return a new token, we also+-- need to update the state of the parser. Why? Because the token is longer+-- than what was lexed by Alex, and the lexToken function doesn't know this, so+-- it writes the wrong token length to the parser state. This function is+-- called afterwards, so it can just update the state.++docCommentEnd :: AlexInput -> String -> (String -> Token) -> StringBuffer ->+                 PsSpan -> P (PsLocated Token)+docCommentEnd input commentAcc docType buf span = do+  setInput input+  let (AI loc nextBuf) = input+      comment = reverse commentAcc+      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) (psRealLoc end) "unterminated `{-'"++open_brace, close_brace :: Action+open_brace span _str _len = do+  ctx <- getContext+  setContext (NoLayout:ctx)+  return (L span ITocurly)+close_brace span _str _len = do+  popContext+  return (L span ITccurly)++qvarid, qconid :: StringBuffer -> Int -> Token+qvarid buf len = ITqvarid $! splitQualName buf len False+qconid buf len = ITqconid $! splitQualName buf len False++splitQualName :: StringBuffer -> Int -> Bool -> (FastString,FastString)+-- takes a StringBuffer and a length, and returns the module name+-- and identifier parts of a qualified name.  Splits at the *last* dot,+-- because of hierarchical module names.+splitQualName orig_buf len parens = split orig_buf orig_buf+  where+    split buf dot_buf+        | orig_buf `byteDiff` buf >= len  = done dot_buf+        | c == '.'                        = found_dot buf'+        | otherwise                       = split buf' dot_buf+      where+       (c,buf') = nextChar buf++    -- careful, we might get names like M....+    -- so, if the character after the dot is not upper-case, this is+    -- the end of the qualifier part.+    found_dot buf -- buf points after the '.'+        | isUpper c    = split buf' buf+        | otherwise    = done buf+      where+       (c,buf') = nextChar buf++    done dot_buf =+        (lexemeToFastString orig_buf (qual_size - 1),+         if parens -- Prelude.(+)+            then lexemeToFastString (stepOn dot_buf) (len - qual_size - 2)+            else lexemeToFastString dot_buf (len - qual_size))+      where+        qual_size = orig_buf `byteDiff` dot_buf++varid :: Action+varid span buf len =+  case lookupUFM reservedWordsFM fs of+    Just (ITcase, _) -> do+      lastTk <- getLastTk+      keyword <- case lastTk of+        Just ITlam -> do+          lambdaCase <- getBit LambdaCaseBit+          unless lambdaCase $ do+            pState <- getPState+            addError (mkSrcSpanPs (last_loc pState)) $ text+                     "Illegal lambda-case (use LambdaCase)"+          return ITlcase+        _ -> return ITcase+      maybe_layout keyword+      return $ L span keyword+    Just (keyword, 0) -> do+      maybe_layout keyword+      return $ L span keyword+    Just (keyword, i) -> do+      exts <- getExts+      if exts .&. i /= 0+        then do+          maybe_layout keyword+          return $ L span keyword+        else+          return $ L span $ ITvarid fs+    Nothing ->+      return $ L span $ ITvarid fs+  where+    !fs = lexemeToFastString buf len++conid :: StringBuffer -> Int -> Token+conid buf len = ITconid $! lexemeToFastString buf len++qvarsym, qconsym :: StringBuffer -> Int -> Token+qvarsym buf len = ITqvarsym $! splitQualName buf len False+qconsym buf len = ITqconsym $! splitQualName buf len False++-- See Note [Whitespace-sensitive operator parsing]+varsym_prefix :: Action+varsym_prefix = sym $ \exts s ->+  if | TypeApplicationsBit `xtest` exts, s == fsLit "@"+     -> return ITtypeApp+     | ThQuotesBit `xtest` exts, s == fsLit "$"+     -> return ITdollar+     | ThQuotesBit `xtest` exts, s == fsLit "$$"+     -> return ITdollardollar+     | s == fsLit "!" -> return ITbang+     | s == fsLit "~" -> return ITtilde+     | otherwise -> return (ITvarsym s)++-- See Note [Whitespace-sensitive operator parsing]+varsym_suffix :: Action+varsym_suffix = sym $ \_ s ->+  if | s == fsLit "@"+     -> failMsgP "Suffix occurrence of @. For an as-pattern, remove the leading whitespace."+     | otherwise -> return (ITvarsym s)++-- See Note [Whitespace-sensitive operator parsing]+varsym_tight_infix :: Action+varsym_tight_infix = sym $ \_ s ->+  if | s == fsLit "@" -> return ITat+     | otherwise -> return (ITvarsym s)++-- See Note [Whitespace-sensitive operator parsing]+varsym_loose_infix :: Action+varsym_loose_infix = sym (\_ s -> return $ ITvarsym s)++consym :: Action+consym = sym (\_exts s -> return $ ITconsym s)++sym :: (ExtsBitmap -> FastString -> P Token) -> Action+sym con span buf len =+  case lookupUFM reservedSymsFM fs of+    Just (keyword, NormalSyntax, 0) ->+      return $ L span keyword+    Just (keyword, NormalSyntax, i) -> do+      exts <- getExts+      if exts .&. i /= 0+        then return $ L span keyword+        else L span <$!> con exts fs+    Just (keyword, UnicodeSyntax, 0) -> do+      exts <- getExts+      if xtest UnicodeSyntaxBit exts+        then return $ L span keyword+        else L span <$!> con exts fs+    Just (keyword, UnicodeSyntax, i) -> do+      exts <- getExts+      if exts .&. i /= 0 && xtest UnicodeSyntaxBit exts+        then return $ L span keyword+        else L span <$!> con exts fs+    Nothing -> do+      exts <- getExts+      L span <$!> con exts fs+  where+    !fs = lexemeToFastString buf len++-- Variations on the integral numeric literal.+tok_integral :: (SourceText -> Integer -> Token)+             -> (Integer -> Integer)+             -> Int -> Int+             -> (Integer, (Char -> Int))+             -> Action+tok_integral itint transint transbuf translen (radix,char_to_int) span buf len = do+  numericUnderscores <- getBit NumericUnderscoresBit  -- #14473+  let src = lexemeToString buf len+  when ((not numericUnderscores) && ('_' `elem` src)) $ do+    pState <- getPState+    addError (mkSrcSpanPs (last_loc pState)) $ text+             "Use NumericUnderscores to allow underscores in integer literals"+  return $ L span $ itint (SourceText src)+       $! transint $ parseUnsignedInteger+       (offsetBytes transbuf buf) (subtract translen len) radix char_to_int++tok_num :: (Integer -> Integer)+        -> Int -> Int+        -> (Integer, (Char->Int)) -> Action+tok_num = tok_integral $ \case+    st@(SourceText ('-':_)) -> itint st (const True)+    st@(SourceText _)       -> itint st (const False)+    st@NoSourceText         -> itint st (< 0)+  where+    itint :: SourceText -> (Integer -> Bool) -> Integer -> Token+    itint !st is_negative !val = ITinteger ((IL st $! is_negative val) val)++tok_primint :: (Integer -> Integer)+            -> Int -> Int+            -> (Integer, (Char->Int)) -> Action+tok_primint = tok_integral ITprimint+++tok_primword :: Int -> Int+             -> (Integer, (Char->Int)) -> Action+tok_primword = tok_integral ITprimword positive+positive, negative :: (Integer -> Integer)+positive = id+negative = negate+decimal, octal, hexadecimal :: (Integer, Char -> Int)+decimal = (10,octDecDigit)+binary = (2,octDecDigit)+octal = (8,octDecDigit)+hexadecimal = (16,hexDigit)++-- readRational can understand negative rationals, exponents, everything.+tok_frac :: Int -> (String -> Token) -> Action+tok_frac drop f span buf len = do+  numericUnderscores <- getBit NumericUnderscoresBit  -- #14473+  let src = lexemeToString buf (len-drop)+  when ((not numericUnderscores) && ('_' `elem` src)) $ do+    pState <- getPState+    addError (mkSrcSpanPs (last_loc pState)) $ text+             "Use NumericUnderscores to allow underscores in floating literals"+  return (L span $! (f $! src))++tok_float, tok_primfloat, tok_primdouble :: String -> Token+tok_float        str = ITrational   $! readFractionalLit str+tok_hex_float    str = ITrational   $! readHexFractionalLit str+tok_primfloat    str = ITprimfloat  $! readFractionalLit str+tok_primdouble   str = ITprimdouble $! readFractionalLit str++readFractionalLit :: String -> FractionalLit+readFractionalLit str = ((FL $! (SourceText str)) $! is_neg) $! readRational str+                        where is_neg = case str of ('-':_) -> True+                                                   _       -> False+readHexFractionalLit :: String -> FractionalLit+readHexFractionalLit str =+  FL { fl_text  = SourceText str+     , fl_neg   = case str of+                    '-' : _ -> True+                    _       -> False+     , fl_value = readHexRational str+     }++-- -----------------------------------------------------------------------------+-- Layout processing++-- we're at the first token on a line, insert layout tokens if necessary+do_bol :: Action+do_bol span _str _len = do+        -- See Note [Nested comment line pragmas]+        b <- getBit InNestedCommentBit+        if b then return (L span ITcomment_line_prag) else do+          (pos, gen_semic) <- getOffside+          case pos of+              LT -> do+                  --trace "layout: inserting '}'" $ do+                  popContext+                  -- do NOT pop the lex state, we might have a ';' to insert+                  return (L span ITvccurly)+              EQ | gen_semic -> do+                  --trace "layout: inserting ';'" $ do+                  _ <- popLexState+                  return (L span ITsemi)+              _ -> do+                  _ <- popLexState+                  lexToken++-- certain keywords put us in the "layout" state, where we might+-- add an opening curly brace.+maybe_layout :: Token -> P ()+maybe_layout t = do -- If the alternative layout rule is enabled then+                    -- we never create an implicit layout context here.+                    -- Layout is handled XXX instead.+                    -- The code for closing implicit contexts, or+                    -- inserting implicit semi-colons, is therefore+                    -- irrelevant as it only applies in an implicit+                    -- context.+                    alr <- getBit AlternativeLayoutRuleBit+                    unless alr $ f t+    where f ITdo    = pushLexState layout_do+          f ITmdo   = pushLexState layout_do+          f ITof    = pushLexState layout+          f ITlcase = pushLexState layout+          f ITlet   = pushLexState layout+          f ITwhere = pushLexState layout+          f ITrec   = pushLexState layout+          f ITif    = pushLexState layout_if+          f _       = return ()++-- Pushing a new implicit layout context.  If the indentation of the+-- next token is not greater than the previous layout context, then+-- Haskell 98 says that the new layout context should be empty; that is+-- the lexer must generate {}.+--+-- We are slightly more lenient than this: when the new context is started+-- by a 'do', then we allow the new context to be at the same indentation as+-- the previous context.  This is what the 'strict' argument is for.+new_layout_context :: Bool -> Bool -> Token -> Action+new_layout_context strict gen_semic tok span _buf len = do+    _ <- popLexState+    (AI l _) <- getInput+    let offset = srcLocCol (psRealLoc l) - len+    ctx <- getContext+    nondecreasing <- getBit NondecreasingIndentationBit+    let strict' = strict || not nondecreasing+    case ctx of+        Layout prev_off _ : _  |+           (strict'     && prev_off >= offset  ||+            not strict' && prev_off > offset) -> do+                -- token is indented to the left of the previous context.+                -- we must generate a {} sequence now.+                pushLexState layout_left+                return (L span tok)+        _ -> do setContext (Layout offset gen_semic : ctx)+                return (L span tok)++do_layout_left :: Action+do_layout_left span _buf _len = do+    _ <- popLexState+    pushLexState bol  -- we must be at the start of a line+    return (L span ITvccurly)++-- -----------------------------------------------------------------------------+-- LINE pragmas++setLineAndFile :: Int -> Action+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+      file = mkFastString $ go $ drop 1 $ dropWhile (/= '"') src+          -- skip everything through first quotation mark to get to the filename+        where go ('\\':c:cs) = c : go cs+              go (c:cs)      = c : go cs+              go []          = []+              -- decode escapes in the filename.  e.g. on Windows+              -- when our filenames have backslashes in, gcc seems to+              -- escape the backslashes.  One symptom of not doing this+              -- is that filenames in error messages look a bit strange:+              --   C:\\foo\bar.hs+              -- only the first backslash is doubled, because we apply+              -- System.FilePath.normalise before printing out+              -- filenames and it does not remove duplicate+              -- backslashes after the drive letter (should it?).+  resetAlrLastLoc file+  setSrcLoc (mkRealSrcLoc file (fromIntegral linenum - 1) (srcSpanEndCol span))+      -- subtract one: the line number refers to the *following* line+  addSrcFile file+  _ <- popLexState+  pushLexState code+  lexToken++setColumn :: Action+setColumn (PsSpan span _) buf len = do+  let column =+        case reads (lexemeToString buf len) of+          [(column, _)] -> column+          _ -> error "setColumn: expected integer" -- shouldn't happen+  setSrcLoc (mkRealSrcLoc (srcSpanFile span) (srcSpanEndLine span)+                          (fromIntegral (column :: Integer)))+  _ <- popLexState+  lexToken++alrInitialLoc :: FastString -> RealSrcSpan+alrInitialLoc file = mkRealSrcSpan loc loc+    where -- This is a hack to ensure that the first line in a file+          -- looks like it is after the initial location:+          loc = mkRealSrcLoc file (-1) (-1)++-- -----------------------------------------------------------------------------+-- Options, includes and language pragmas.++lex_string_prag :: (String -> Token) -> Action+lex_string_prag mkTok span _buf _len+    = do input <- getInput+         start <- getParsedLoc+         tok <- go [] input+         end <- getParsedLoc+         return (L (mkPsSpan start end) tok)+    where go acc input+              = if isString input "#-}"+                   then do setInput input+                           return (mkTok (reverse acc))+                   else case alexGetChar input of+                          Just (c,i) -> go (c:acc) i+                          Nothing -> err input+          isString _ [] = True+          isString i (x:xs)+              = case alexGetChar i of+                  Just (c,i') | c == x    -> isString i' xs+                  _other -> False+          err (AI end _) = failLocMsgP (realSrcSpanStart (psRealSpan span)) (psRealLoc end) "unterminated options pragma"+++-- -----------------------------------------------------------------------------+-- Strings & Chars++-- This stuff is horrible.  I hates it.++lex_string_tok :: Action+lex_string_tok span buf _len = do+  tok <- lex_string ""+  (AI end bufEnd) <- getInput+  let+    tok' = case tok of+            ITprimstring _ bs -> ITprimstring (SourceText src) bs+            ITstring _ s -> ITstring (SourceText src) s+            _ -> panic "lex_string_tok"+    src = lexemeToString buf (cur bufEnd - cur buf)+  return (L (mkPsSpan (psSpanStart span) end) tok')++lex_string :: String -> P Token+lex_string s = do+  i <- getInput+  case alexGetChar' i of+    Nothing -> lit_error i++    Just ('"',i)  -> do+        setInput i+        let s' = reverse s+        magicHash <- getBit MagicHashBit+        if magicHash+          then do+            i <- getInput+            case alexGetChar' i of+              Just ('#',i) -> do+                setInput i+                when (any (> '\xFF') s') $ do+                  pState <- getPState+                  addError (mkSrcSpanPs (last_loc pState)) $ text+                     "primitive string literal must contain only characters <= \'\\xFF\'"+                return (ITprimstring (SourceText s') (unsafeMkByteString s'))+              _other ->+                return (ITstring (SourceText s') (mkFastString s'))+          else+                return (ITstring (SourceText s') (mkFastString s'))++    Just ('\\',i)+        | Just ('&',i) <- next -> do+                setInput i; lex_string s+        | Just (c,i) <- next, c <= '\x7f' && is_space c -> do+                           -- is_space only works for <= '\x7f' (#3751, #5425)+                setInput i; lex_stringgap s+        where next = alexGetChar' i++    Just (c, i1) -> do+        case c of+          '\\' -> do setInput i1; c' <- lex_escape; lex_string (c':s)+          c | isAny c -> do setInput i1; lex_string (c:s)+          _other -> lit_error i++lex_stringgap :: String -> P Token+lex_stringgap s = do+  i <- getInput+  c <- getCharOrFail i+  case c of+    '\\' -> lex_string s+    c | c <= '\x7f' && is_space c -> lex_stringgap s+                           -- is_space only works for <= '\x7f' (#3751, #5425)+    _other -> lit_error i+++lex_char_tok :: Action+-- Here we are basically parsing character literals, such as 'x' or '\n'+-- but we additionally spot 'x and ''T, returning ITsimpleQuote and+-- ITtyQuote respectively, but WITHOUT CONSUMING the x or T part+-- (the parser does that).+-- So we have to do two characters of lookahead: when we see 'x we need to+-- 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 = psSpanStart span+   case alexGetChar' i1 of+        Nothing -> lit_error  i1++        Just ('\'', i2@(AI end2 _)) -> do       -- We've seen ''+                   setInput i2+                   return (L (mkPsSpan loc end2)  ITtyQuote)++        Just ('\\', i2@(AI _end2 _)) -> do      -- We've seen 'backslash+                  setInput i2+                  lit_ch <- lex_escape+                  i3 <- getInput+                  mc <- getCharOrFail i3 -- Trailing quote+                  if mc == '\'' then finish_char_tok buf loc lit_ch+                                else lit_error i3++        Just (c, i2@(AI _end2 _))+                | not (isAny c) -> lit_error i1+                | otherwise ->++                -- We've seen 'x, where x is a valid character+                --  (i.e. not newline etc) but not a quote or backslash+           case alexGetChar' i2 of      -- Look ahead one more character+                Just ('\'', i3) -> do   -- We've seen 'x'+                        setInput i3+                        finish_char_tok buf loc c+                _other -> do            -- We've seen 'x not followed by quote+                                        -- (including the possibility of EOF)+                                        -- Just parse the quote only+                        let (AI end _) = i1+                        return (L (mkPsSpan loc end) ITsimpleQuote)++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+        i@(AI end bufEnd) <- getInput+        let src = lexemeToString buf (cur bufEnd - cur buf)+        if magicHash then do+            case alexGetChar' i of+              Just ('#',i@(AI end _)) -> do+                setInput i+                return (L (mkPsSpan loc end)+                          (ITprimchar (SourceText src) ch))+              _other ->+                return (L (mkPsSpan loc end)+                          (ITchar (SourceText src) ch))+            else do+              return (L (mkPsSpan loc end) (ITchar (SourceText src) ch))++isAny :: Char -> Bool+isAny c | c > '\x7f' = isPrint c+        | otherwise  = is_any c++lex_escape :: P Char+lex_escape = do+  i0 <- getInput+  c <- getCharOrFail i0+  case c of+        'a'   -> return '\a'+        'b'   -> return '\b'+        'f'   -> return '\f'+        'n'   -> return '\n'+        'r'   -> return '\r'+        't'   -> return '\t'+        'v'   -> return '\v'+        '\\'  -> return '\\'+        '"'   -> return '\"'+        '\''  -> return '\''+        '^'   -> do i1 <- getInput+                    c <- getCharOrFail i1+                    if c >= '@' && c <= '_'+                        then return (chr (ord c - ord '@'))+                        else lit_error i1++        'x'   -> readNum is_hexdigit 16 hexDigit+        'o'   -> readNum is_octdigit  8 octDecDigit+        x | is_decdigit x -> readNum2 is_decdigit 10 octDecDigit (octDecDigit x)++        c1 ->  do+           i <- getInput+           case alexGetChar' i of+            Nothing -> lit_error i0+            Just (c2,i2) ->+              case alexGetChar' i2 of+                Nothing -> do lit_error i0+                Just (c3,i3) ->+                   let str = [c1,c2,c3] in+                   case [ (c,rest) | (p,c) <- silly_escape_chars,+                                     Just rest <- [stripPrefix p str] ] of+                          (escape_char,[]):_ -> do+                                setInput i3+                                return escape_char+                          (escape_char,_:_):_ -> do+                                setInput i2+                                return escape_char+                          [] -> lit_error i0++readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Char+readNum is_digit base conv = do+  i <- getInput+  c <- getCharOrFail i+  if is_digit c+        then readNum2 is_digit base conv (conv c)+        else lit_error i++readNum2 :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> P Char+readNum2 is_digit base conv i = do+  input <- getInput+  read i input+  where read i input = do+          case alexGetChar' input of+            Just (c,input') | is_digit c -> do+               let i' = i*base + conv c+               if i' > 0x10ffff+                  then setInput input >> lexError "numeric escape sequence out of range"+                  else read i' input'+            _other -> do+              setInput input; return (chr i)+++silly_escape_chars :: [(String, Char)]+silly_escape_chars = [+        ("NUL", '\NUL'),+        ("SOH", '\SOH'),+        ("STX", '\STX'),+        ("ETX", '\ETX'),+        ("EOT", '\EOT'),+        ("ENQ", '\ENQ'),+        ("ACK", '\ACK'),+        ("BEL", '\BEL'),+        ("BS", '\BS'),+        ("HT", '\HT'),+        ("LF", '\LF'),+        ("VT", '\VT'),+        ("FF", '\FF'),+        ("CR", '\CR'),+        ("SO", '\SO'),+        ("SI", '\SI'),+        ("DLE", '\DLE'),+        ("DC1", '\DC1'),+        ("DC2", '\DC2'),+        ("DC3", '\DC3'),+        ("DC4", '\DC4'),+        ("NAK", '\NAK'),+        ("SYN", '\SYN'),+        ("ETB", '\ETB'),+        ("CAN", '\CAN'),+        ("EM", '\EM'),+        ("SUB", '\SUB'),+        ("ESC", '\ESC'),+        ("FS", '\FS'),+        ("GS", '\GS'),+        ("RS", '\RS'),+        ("US", '\US'),+        ("SP", '\SP'),+        ("DEL", '\DEL')+        ]++-- before calling lit_error, ensure that the current input is pointing to+-- the position of the error in the buffer.  This is so that we can report+-- a correct location to the user, but also so we can detect UTF-8 decoding+-- errors if they occur.+lit_error :: AlexInput -> P a+lit_error i = do setInput i; lexError "lexical error in string/character literal"++getCharOrFail :: AlexInput -> P Char+getCharOrFail i =  do+  case alexGetChar' i of+        Nothing -> lexError "unexpected end-of-file in string/character literal"+        Just (c,i)  -> do setInput i; return c++-- -----------------------------------------------------------------------------+-- QuasiQuote++lex_qquasiquote_tok :: Action+lex_qquasiquote_tok span buf len = do+  let (qual, quoter) = splitQualName (stepOn buf) (len - 2) False+  quoteStart <- getParsedLoc+  quote <- lex_quasiquote (psRealLoc quoteStart) ""+  end <- getParsedLoc+  return (L (mkPsSpan (psSpanStart span) end)+           (ITqQuasiQuote (qual,+                           quoter,+                           mkFastString (reverse quote),+                           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 <- getParsedLoc+  quote <- lex_quasiquote (psRealLoc quoteStart) ""+  end <- getParsedLoc+  return (L (mkPsSpan (psSpanStart span) end)+           (ITquasiQuote (mkFastString quoter,+                          mkFastString (reverse quote),+                          mkPsSpan quoteStart end)))++lex_quasiquote :: RealSrcLoc -> String -> P String+lex_quasiquote start s = do+  i <- getInput+  case alexGetChar' i of+    Nothing -> quasiquote_error start++    -- NB: The string "|]" terminates the quasiquote,+    -- with absolutely no escaping. See the extensive+    -- discussion on #5348 for why there is no+    -- escape handling.+    Just ('|',i)+        | Just (']',i) <- alexGetChar' i+        -> do { setInput i; return s }++    Just (c, i) -> do+         setInput i; lex_quasiquote start (c : s)++quasiquote_error :: RealSrcLoc -> P a+quasiquote_error start = do+  (AI end buf) <- getInput+  reportLexError start (psRealLoc end) buf "unterminated quasiquotation"++-- -----------------------------------------------------------------------------+-- Warnings++warnTab :: Action+warnTab srcspan _buf _len = do+    addTabWarning (psRealSpan srcspan)+    lexToken++warnThen :: WarningFlag -> SDoc -> Action -> Action+warnThen option warning action srcspan buf len = do+    addWarning option (RealSrcSpan (psRealSpan srcspan) Nothing) warning+    action srcspan buf len++-- -----------------------------------------------------------------------------+-- The Parse Monad++-- | Do we want to generate ';' layout tokens? In some cases we just want to+-- generate '}', e.g. in MultiWayIf we don't need ';'s because '|' separates+-- alternatives (unlike a `case` expression where we need ';' to as a separator+-- between alternatives).+type GenSemic = Bool++generateSemic, dontGenerateSemic :: GenSemic+generateSemic     = True+dontGenerateSemic = False++data LayoutContext+  = NoLayout+  | Layout !Int !GenSemic+  deriving Show++-- | The result of running a parser.+data ParseResult a+  = POk      -- ^ The parser has consumed a (possibly empty) prefix+             --   of the input and produced a result. Use 'getMessages'+             --   to check for accumulated warnings and non-fatal errors.+      PState -- ^ The resulting parsing state. Can be used to resume parsing.+      a      -- ^ The resulting value.+  | PFailed  -- ^ The parser has consumed a (possibly empty) prefix+             --   of the input and failed.+      PState -- ^ The parsing state right before failure, including the fatal+             --   parse error. 'getMessages' and 'getErrorMessages' must return+             --   a non-empty bag of errors.++-- | Test whether a 'WarningFlag' is set+warnopt :: WarningFlag -> ParserFlags -> Bool+warnopt f options = f `EnumSet.member` pWarningFlags options++-- | The subset of the 'DynFlags' used by the parser.+-- See 'mkParserFlags' or 'mkParserFlags'' for ways to construct this.+data ParserFlags = ParserFlags {+    pWarningFlags   :: EnumSet WarningFlag+  , pThisPackage    :: Unit        -- ^ key of package currently being compiled+  , pExtsBitmap     :: !ExtsBitmap -- ^ bitmap of permitted extensions+  }++data PState = PState {+        buffer     :: StringBuffer,+        options    :: ParserFlags,+        -- This needs to take DynFlags as an argument until+        -- we have a fix for #10143+        messages   :: DynFlags -> Messages,+        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   :: PsSpan,      -- pos of previous token+        last_len   :: !Int,        -- len of previous token+        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 :: [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 (PsLocated Token),+        -- This is what we consider to be the location of the last token+        -- emitted:+        alr_last_loc :: PsSpan,+        -- The stack of layout contexts:+        alr_context :: [ALRContext],+        -- Are we expecting a '{'? If it's Just, then the ALRLayout tells+        -- us what sort of layout the '{' will open:+        alr_expecting_ocurly :: Maybe ALRLayout,+        -- Have we just had the '}' for a let block? If so, than an 'in'+        -- token doesn't need to close anything:+        alr_justClosedExplicitLetBlock :: Bool,++        -- The next three are used to implement Annotations giving the+        -- locations of 'noise' tokens in the source, so that users of+        -- the GHC API can do source to source conversions.+        -- See note [Api annotations] in GHC.Parser.Annotation+        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+        -- current token to happyError, we could at least get rid of last_len.+        -- Getting rid of last_loc would require finding another way to+        -- implement pushCurrentContext (which is only called from one place).++data ALRContext = ALRNoLayout Bool{- does it contain commas? -}+                              Bool{- is it a 'let' block? -}+                | ALRLayout ALRLayout Int+data ALRLayout = ALRLayoutLet+               | ALRLayoutWhere+               | ALRLayoutOf+               | ALRLayoutDo++-- | The parsing monad, isomorphic to @StateT PState Maybe@.+newtype P a = P { unP :: PState -> ParseResult a }++instance Functor P where+  fmap = liftM++instance Applicative P where+  pure = returnP+  (<*>) = ap++instance Monad P where+  (>>=) = thenP++returnP :: a -> P a+returnP a = a `seq` (P $ \s -> POk s a)++thenP :: P a -> (a -> P b) -> P b+(P m) `thenP` k = P $ \ s ->+        case m s of+                POk s1 a         -> (unP (k a)) s1+                PFailed s1 -> PFailed s1++failMsgP :: String -> P a+failMsgP msg = do+  pState <- getPState+  addFatalError (mkSrcSpanPs (last_loc pState)) (text msg)++failLocMsgP :: RealSrcLoc -> RealSrcLoc -> String -> P a+failLocMsgP loc1 loc2 str =+  addFatalError (RealSrcSpan (mkRealSrcSpan loc1 loc2) Nothing) (text str)++getPState :: P PState+getPState = P $ \s -> POk s s++withThisPackage :: (Unit -> a) -> P a+withThisPackage f = P $ \s@(PState{options = o}) -> POk s (f (pThisPackage o))++getExts :: P ExtsBitmap+getExts = P $ \s -> POk s (pExtsBitmap . options $ s)++setExts :: (ExtsBitmap -> ExtsBitmap) -> P ()+setExts f = P $ \s -> POk s {+  options =+    let p = options s+    in  p { pExtsBitmap = f (pExtsBitmap p) }+  } ()++setSrcLoc :: RealSrcLoc -> P ()+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 (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 } ()++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+  } ()++setLastTk :: Token -> P ()+setLastTk tk = P $ \s -> POk s { last_tk = Just tk } ()++getLastTk :: P (Maybe Token)+getLastTk = P $ \s@(PState { last_tk = last_tk }) -> POk s last_tk++data AlexInput = AI PsLoc StringBuffer++{-+Note [Unicode in Alex]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Although newer versions of Alex support unicode, this grammar is processed with+the old style '--latin1' behaviour. This means that when implementing the+functions++    alexGetByte       :: AlexInput -> Maybe (Word8,AlexInput)+    alexInputPrevChar :: AlexInput -> Char++which Alex uses to take apart our 'AlexInput', we must++  * return a latin1 character in the 'Word8' that 'alexGetByte' expects+  * return a latin1 character in 'alexInputPrevChar'.++We handle this in 'adjustChar' by squishing entire classes of unicode+characters into single bytes.+-}++{-# INLINE adjustChar #-}+adjustChar :: Char -> Word8+adjustChar c = fromIntegral $ ord adj_c+  where non_graphic     = '\x00'+        upper           = '\x01'+        lower           = '\x02'+        digit           = '\x03'+        symbol          = '\x04'+        space           = '\x05'+        other_graphic   = '\x06'+        uniidchar       = '\x07'++        adj_c+          | c <= '\x07' = non_graphic+          | c <= '\x7f' = c+          -- Alex doesn't handle Unicode, so when Unicode+          -- character is encountered we output these values+          -- with the actual character value hidden in the state.+          | otherwise =+                -- NB: The logic behind these definitions is also reflected+                -- in basicTypes/Lexeme.hs+                -- Any changes here should likely be reflected there.++                case generalCategory c of+                  UppercaseLetter       -> upper+                  LowercaseLetter       -> lower+                  TitlecaseLetter       -> upper+                  ModifierLetter        -> uniidchar -- see #10196+                  OtherLetter           -> lower -- see #1103+                  NonSpacingMark        -> uniidchar -- see #7650+                  SpacingCombiningMark  -> other_graphic+                  EnclosingMark         -> other_graphic+                  DecimalNumber         -> digit+                  LetterNumber          -> other_graphic+                  OtherNumber           -> digit -- see #4373+                  ConnectorPunctuation  -> symbol+                  DashPunctuation       -> symbol+                  OpenPunctuation       -> other_graphic+                  ClosePunctuation      -> other_graphic+                  InitialQuote          -> other_graphic+                  FinalQuote            -> other_graphic+                  OtherPunctuation      -> symbol+                  MathSymbol            -> symbol+                  CurrencySymbol        -> symbol+                  ModifierSymbol        -> symbol+                  OtherSymbol           -> symbol+                  Space                 -> space+                  _other                -> non_graphic++-- Getting the previous 'Char' isn't enough here - we need to convert it into+-- the same format that 'alexGetByte' would have produced.+--+-- See Note [Unicode in Alex] and #13986.+alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (AI _ buf) = chr (fromIntegral (adjustChar pc))+  where pc = prevChar buf '\n'++-- backwards compatibility for Alex 2.x+alexGetChar :: AlexInput -> Maybe (Char,AlexInput)+alexGetChar inp = case alexGetByte inp of+                    Nothing    -> Nothing+                    Just (b,i) -> c `seq` Just (c,i)+                       where c = chr $ fromIntegral b++-- See Note [Unicode in Alex]+alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+alexGetByte (AI loc s)+  | atEnd s   = Nothing+  | otherwise = byte `seq` loc' `seq` s' `seq`+                --trace (show (ord c)) $+                Just (byte, (AI loc' s'))+  where (c,s') = nextChar s+        loc'   = advancePsLoc loc c+        byte   = adjustChar c++-- This version does not squash unicode characters, it is used when+-- lexing strings.+alexGetChar' :: AlexInput -> Maybe (Char,AlexInput)+alexGetChar' (AI loc s)+  | atEnd s   = Nothing+  | otherwise = c `seq` loc' `seq` s' `seq`+                --trace (show (ord c)) $+                Just (c, (AI loc' s'))+  where (c,s') = nextChar s+        loc'   = advancePsLoc loc c++getInput :: P AlexInput+getInput = P $ \s@PState{ loc=l, buffer=b } -> POk s (AI l b)++setInput :: AlexInput -> P ()+setInput (AI l b) = P $ \s -> POk s{ loc=l, buffer=b } ()++nextIsEOF :: P Bool+nextIsEOF = do+  AI _ s <- getInput+  return $ atEnd s++pushLexState :: Int -> P ()+pushLexState ls = P $ \s@PState{ lex_state=l } -> POk s{lex_state=ls:l} ()++popLexState :: P Int+popLexState = P $ \s@PState{ lex_state=ls:l } -> POk s{ lex_state=l } ls++getLexState :: P Int+getLexState = P $ \s@PState{ lex_state=ls:_ } -> POk s ls++popNextToken :: P (Maybe (PsLocated Token))+popNextToken+    = P $ \s@PState{ alr_next_token = m } ->+              POk (s {alr_next_token = Nothing}) m++activeContext :: P Bool+activeContext = do+  ctxt <- getALRContext+  expc <- getAlrExpectingOCurly+  impt <- implicitTokenPending+  case (ctxt,expc) of+    ([],Nothing) -> return impt+    _other       -> return True++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 PsSpan+getAlrLastLoc = P $ \s@(PState {alr_last_loc = l}) -> POk s l++getALRContext :: P [ALRContext]+getALRContext = P $ \s@(PState {alr_context = cs}) -> POk s cs++setALRContext :: [ALRContext] -> P ()+setALRContext cs = P $ \s -> POk (s {alr_context = cs}) ()++getJustClosedExplicitLetBlock :: P Bool+getJustClosedExplicitLetBlock+ = P $ \s@(PState {alr_justClosedExplicitLetBlock = b}) -> POk s b++setJustClosedExplicitLetBlock :: Bool -> P ()+setJustClosedExplicitLetBlock b+ = P $ \s -> POk (s {alr_justClosedExplicitLetBlock = b}) ()++setNextToken :: PsLocated Token -> P ()+setNextToken t = P $ \s -> POk (s {alr_next_token = Just t}) ()++implicitTokenPending :: P Bool+implicitTokenPending+    = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->+              case ts of+              [] -> POk s False+              _  -> POk s True++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 :: [PsLocated Token] -> P ()+setPendingImplicitTokens ts = P $ \s -> POk (s {alr_pending_implicit_tokens = ts}) ()++getAlrExpectingOCurly :: P (Maybe ALRLayout)+getAlrExpectingOCurly = P $ \s@(PState {alr_expecting_ocurly = b}) -> POk s b++setAlrExpectingOCurly :: Maybe ALRLayout -> P ()+setAlrExpectingOCurly b = P $ \s -> POk (s {alr_expecting_ocurly = b}) ()++-- | For reasons of efficiency, boolean parsing flags (eg, language extensions+-- or whether we are currently in a @RULE@ pragma) are represented by a bitmap+-- stored in a @Word64@.+type ExtsBitmap = Word64++xbit :: ExtBits -> ExtsBitmap+xbit = bit . fromEnum++xtest :: ExtBits -> ExtsBitmap -> Bool+xtest ext xmap = testBit xmap (fromEnum ext)++-- | Various boolean flags, mostly language extensions, that impact lexing and+-- parsing. Note that a handful of these can change during lexing/parsing.+data ExtBits+  -- Flags that are constant once parsing starts+  = FfiBit+  | InterruptibleFfiBit+  | CApiFfiBit+  | ArrowsBit+  | ThBit+  | ThQuotesBit+  | IpBit+  | OverloadedLabelsBit -- #x overloaded labels+  | ExplicitForallBit -- the 'forall' keyword+  | BangPatBit -- Tells the parser to understand bang-patterns+               -- (doesn't affect the lexer)+  | PatternSynonymsBit -- pattern synonyms+  | HaddockBit-- Lex and parse Haddock comments+  | MagicHashBit -- "#" in both functions and operators+  | RecursiveDoBit -- mdo+  | UnicodeSyntaxBit -- the forall symbol, arrow symbols, etc+  | UnboxedTuplesBit -- (# and #)+  | UnboxedSumsBit -- (# and #)+  | DatatypeContextsBit+  | MonadComprehensionsBit+  | TransformComprehensionsBit+  | QqBit -- enable quasiquoting+  | RawTokenStreamBit -- producing a token stream with all comments included+  | AlternativeLayoutRuleBit+  | ALRTransitionalBit+  | RelaxedLayoutBit+  | NondecreasingIndentationBit+  | SafeHaskellBit+  | TraditionalRecordSyntaxBit+  | ExplicitNamespacesBit+  | LambdaCaseBit+  | BinaryLiteralsBit+  | NegativeLiteralsBit+  | HexFloatLiteralsBit+  | TypeApplicationsBit+  | StaticPointersBit+  | NumericUnderscoresBit+  | StarIsTypeBit+  | BlockArgumentsBit+  | NPlusKPatternsBit+  | DoAndIfThenElseBit+  | MultiWayIfBit+  | GadtSyntaxBit+  | ImportQualifiedPostBit++  -- Flags that are updated once parsing starts+  | InRulePragBit+  | InNestedCommentBit -- See Note [Nested comment line pragmas]+  | UsePosPragsBit+    -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}'+    -- update the internal position. Otherwise, those pragmas are lexed as+    -- tokens of their own.+  deriving Enum++++++-- PState for parsing options pragmas+--+pragState :: DynFlags -> StringBuffer -> RealSrcLoc -> PState+pragState dynflags buf loc = (mkPState dynflags buf loc) {+                                 lex_state = [bol, option_prags, 0]+                             }++{-# INLINE mkParserFlags' #-}+mkParserFlags'+  :: EnumSet WarningFlag        -- ^ warnings flags enabled+  -> EnumSet LangExt.Extension  -- ^ permitted language extensions enabled+  -> Unit                       -- ^ key of package currently being compiled+  -> Bool                       -- ^ are safe imports on?+  -> Bool                       -- ^ keeping Haddock comment tokens+  -> Bool                       -- ^ keep regular comment tokens++  -> Bool+  -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update+  -- the internal position kept by the parser. Otherwise, those pragmas are+  -- lexed as 'ITline_prag' and 'ITcolumn_prag' tokens.++  -> ParserFlags+-- ^ Given exactly the information needed, set up the 'ParserFlags'+mkParserFlags' warningFlags extensionFlags thisPackage+  safeImports isHaddock rawTokStream usePosPrags =+    ParserFlags {+      pWarningFlags = warningFlags+    , pThisPackage = thisPackage+    , pExtsBitmap = safeHaskellBit .|. langExtBits .|. optBits+    }+  where+    safeHaskellBit = SafeHaskellBit `setBitIf` safeImports+    langExtBits =+          FfiBit                      `xoptBit` LangExt.ForeignFunctionInterface+      .|. InterruptibleFfiBit         `xoptBit` LangExt.InterruptibleFFI+      .|. CApiFfiBit                  `xoptBit` LangExt.CApiFFI+      .|. ArrowsBit                   `xoptBit` LangExt.Arrows+      .|. ThBit                       `xoptBit` LangExt.TemplateHaskell+      .|. ThQuotesBit                 `xoptBit` LangExt.TemplateHaskellQuotes+      .|. QqBit                       `xoptBit` LangExt.QuasiQuotes+      .|. IpBit                       `xoptBit` LangExt.ImplicitParams+      .|. OverloadedLabelsBit         `xoptBit` LangExt.OverloadedLabels+      .|. ExplicitForallBit           `xoptBit` LangExt.ExplicitForAll+      .|. BangPatBit                  `xoptBit` LangExt.BangPatterns+      .|. MagicHashBit                `xoptBit` LangExt.MagicHash+      .|. RecursiveDoBit              `xoptBit` LangExt.RecursiveDo+      .|. UnicodeSyntaxBit            `xoptBit` LangExt.UnicodeSyntax+      .|. UnboxedTuplesBit            `xoptBit` LangExt.UnboxedTuples+      .|. UnboxedSumsBit              `xoptBit` LangExt.UnboxedSums+      .|. DatatypeContextsBit         `xoptBit` LangExt.DatatypeContexts+      .|. TransformComprehensionsBit  `xoptBit` LangExt.TransformListComp+      .|. MonadComprehensionsBit      `xoptBit` LangExt.MonadComprehensions+      .|. AlternativeLayoutRuleBit    `xoptBit` LangExt.AlternativeLayoutRule+      .|. ALRTransitionalBit          `xoptBit` LangExt.AlternativeLayoutRuleTransitional+      .|. RelaxedLayoutBit            `xoptBit` LangExt.RelaxedLayout+      .|. NondecreasingIndentationBit `xoptBit` LangExt.NondecreasingIndentation+      .|. TraditionalRecordSyntaxBit  `xoptBit` LangExt.TraditionalRecordSyntax+      .|. ExplicitNamespacesBit       `xoptBit` LangExt.ExplicitNamespaces+      .|. LambdaCaseBit               `xoptBit` LangExt.LambdaCase+      .|. BinaryLiteralsBit           `xoptBit` LangExt.BinaryLiterals+      .|. NegativeLiteralsBit         `xoptBit` LangExt.NegativeLiterals+      .|. HexFloatLiteralsBit         `xoptBit` LangExt.HexFloatLiterals+      .|. PatternSynonymsBit          `xoptBit` LangExt.PatternSynonyms+      .|. TypeApplicationsBit         `xoptBit` LangExt.TypeApplications+      .|. StaticPointersBit           `xoptBit` LangExt.StaticPointers+      .|. NumericUnderscoresBit       `xoptBit` LangExt.NumericUnderscores+      .|. StarIsTypeBit               `xoptBit` LangExt.StarIsType+      .|. BlockArgumentsBit           `xoptBit` LangExt.BlockArguments+      .|. NPlusKPatternsBit           `xoptBit` LangExt.NPlusKPatterns+      .|. DoAndIfThenElseBit          `xoptBit` LangExt.DoAndIfThenElse+      .|. MultiWayIfBit               `xoptBit` LangExt.MultiWayIf+      .|. GadtSyntaxBit               `xoptBit` LangExt.GADTSyntax+      .|. ImportQualifiedPostBit      `xoptBit` LangExt.ImportQualifiedPost+    optBits =+          HaddockBit        `setBitIf` isHaddock+      .|. RawTokenStreamBit `setBitIf` rawTokStream+      .|. UsePosPragsBit    `setBitIf` usePosPrags++    xoptBit bit ext = bit `setBitIf` EnumSet.member ext extensionFlags++    setBitIf :: ExtBits -> Bool -> ExtsBitmap+    b `setBitIf` cond | cond      = xbit b+                      | otherwise = 0++-- | Extracts the flag information needed for parsing+mkParserFlags :: DynFlags -> ParserFlags+mkParserFlags =+  mkParserFlags'+    <$> DynFlags.warningFlags+    <*> DynFlags.extensionFlags+    <*> DynFlags.thisPackage+    <*> safeImportsOn+    <*> gopt Opt_Haddock+    <*> gopt Opt_KeepRawTokenStream+    <*> const True++-- | Creates a parse state from a 'DynFlags' value+mkPState :: DynFlags -> StringBuffer -> RealSrcLoc -> PState+mkPState flags = mkPStatePure (mkParserFlags flags)++-- | Creates a parse state from a 'ParserFlags' value+mkPStatePure :: ParserFlags -> StringBuffer -> RealSrcLoc -> PState+mkPStatePure options buf loc =+  PState {+      buffer        = buf,+      options       = options,+      messages      = const emptyMessages,+      tab_first     = Nothing,+      tab_count     = 0,+      last_tk       = Nothing,+      last_loc      = mkPsSpan init_loc init_loc,+      last_len      = 0,+      loc           = init_loc,+      context       = [],+      lex_state     = [bol, 0],+      srcfiles      = [],+      alr_pending_implicit_tokens = [],+      alr_next_token = Nothing,+      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,+-- disambiguate, or rearrange them, and we do so in the PV monad which cannot consume+-- input but can report parsing errors, check for extension bits, and accumulate+-- parsing annotations. Both P and PV are instances of MonadP.+--+-- MonadP grants us convenient overloading. The other option is to have separate operations+-- for each monad: addErrorP vs addErrorPV, getBitP vs getBitPV, and so on.+--+class Monad m => MonadP m where+  -- | Add a non-fatal error. Use this when the parser can produce a result+  --   despite the error.+  --+  --   For example, when GHC encounters a @forall@ in a type,+  --   but @-XExplicitForAll@ is disabled, the parser constructs @ForAllTy@+  --   as if @-XExplicitForAll@ was enabled, adding a non-fatal error to+  --   the accumulator.+  --+  --   Control flow wise, non-fatal errors act like warnings: they are added+  --   to the accumulator and parsing continues. This allows GHC to report+  --   more than one parse error per file.+  --+  addError :: SrcSpan -> SDoc -> m ()+  -- | Add a warning to the accumulator.+  --   Use 'getMessages' to get the accumulated warnings.+  addWarning :: WarningFlag -> SrcSpan -> SDoc -> m ()+  -- | Add a fatal error. This will be the last error reported by the parser, and+  --   the parser will not produce any result, ending in a 'PFailed' state.+  addFatalError :: SrcSpan -> SDoc -> m a+  -- | Check if a given flag is currently set in the bitmap.+  getBit :: ExtBits -> m Bool+  -- | Given a location and a list of AddAnn, apply them all to the location.+  addAnnotation :: SrcSpan          -- SrcSpan of enclosing AST construct+                -> AnnKeywordId     -- The first two parameters are the key+                -> SrcSpan          -- The location of the keyword itself+                -> m ()++appendError+  :: SrcSpan+  -> SDoc+  -> (DynFlags -> Messages)+  -> (DynFlags -> Messages)+appendError srcspan msg m =+  \d ->+    let (ws, es) = m d+        errormsg = mkErrMsg d srcspan alwaysQualify msg+        es' = es `snocBag` errormsg+    in (ws, es')++appendWarning+  :: ParserFlags+  -> WarningFlag+  -> SrcSpan+  -> SDoc+  -> (DynFlags -> Messages)+  -> (DynFlags -> Messages)+appendWarning o option srcspan warning m =+  \d ->+    let (ws, es) = m d+        warning' = makeIntoWarning (Reason option) $+           mkWarnMsg d srcspan alwaysQualify warning+        ws' = if warnopt option o then ws `snocBag` warning' else ws+    in (ws', es)++instance MonadP P where+  addError srcspan msg+   = P $ \s@PState{messages=m} ->+             POk s{messages=appendError srcspan msg m} ()+  addWarning option srcspan warning+   = P $ \s@PState{messages=m, options=o} ->+             POk s{messages=appendWarning o option srcspan warning m} ()+  addFatalError span msg =+    addError span msg >> P PFailed+  getBit ext = P $ \s -> let b =  ext `xtest` pExtsBitmap (options s)+                         in b `seq` POk s b+  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)++addTabWarning :: RealSrcSpan -> P ()+addTabWarning srcspan+ = P $ \s@PState{tab_first=tf, tab_count=tc, options=o} ->+       let tf' = if isJust tf then tf else Just srcspan+           tc' = tc + 1+           s' = if warnopt Opt_WarnTabs o+                then s{tab_first = tf', tab_count = tc'}+                else s+       in POk s' ()++mkTabWarning :: PState -> DynFlags -> Maybe ErrMsg+mkTabWarning PState{tab_first=tf, tab_count=tc} d =+  let middle = if tc == 1+        then text ""+        else text ", and in" <+> speakNOf (tc - 1) (text "further location")+      message = text "Tab character found here"+                <> middle+                <> text "."+                $+$ text "Please use spaces instead."+  in fmap (\s -> makeIntoWarning (Reason Opt_WarnTabs) $+                 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.+getErrorMessages :: PState -> DynFlags -> ErrorMessages+getErrorMessages PState{messages=m} d =+  let (_, es) = m d in es++-- | Get the warnings and errors accumulated so far.+--   Does not take -Werror into account.+getMessages :: PState -> DynFlags -> Messages+getMessages p@PState{messages=m} d =+  let (ws, es) = m d+      tabwarning = mkTabWarning p d+      ws' = maybe ws (`consBag` ws) tabwarning+  in (ws', es)++getContext :: P [LayoutContext]+getContext = P $ \s@PState{context=ctx} -> POk s ctx++setContext :: [LayoutContext] -> P ()+setContext ctx = P $ \s -> POk s{context=ctx} ()++popContext :: P ()+popContext = P $ \ s@(PState{ buffer = buf, options = o, context = ctx,+                              last_len = len, last_loc = last_loc }) ->+  case ctx of+        (_:tl) ->+          POk s{ context = tl } ()+        []     ->+          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 (psRealSpan loc)) gen_semic : ctx} ()++-- This is only used at the outer level of a module when the 'module' keyword is+-- missing.+pushModuleContext :: P ()+pushModuleContext = pushCurrentContext generateSemic++getOffside :: P (Ordering, Bool)+getOffside = P $ \s@PState{last_loc=loc, context=stk} ->+                let offs = srcSpanStartCol (psRealSpan loc) in+                let ord = case stk of+                            Layout n gen_semic : _ ->+                              --trace ("layout: " ++ show n ++ ", offs: " ++ show offs) $+                              (compare offs n, gen_semic)+                            _ ->+                              (GT, dontGenerateSemic)+                in POk s ord++-- ---------------------------------------------------------------------------+-- Construct a parse error++srcParseErr+  :: ParserFlags+  -> StringBuffer       -- current buffer (placed just after the last token)+  -> Int                -- length of the previous token+  -> MsgDoc+srcParseErr options buf len+  = if null token+         then text "parse error (possibly incorrect indentation or mismatched brackets)"+         else text "parse error on input" <+> quotes (text token)+              $$ ppWhen (not th_enabled && token == "$") -- #7396+                        (text "Perhaps you intended to use TemplateHaskell")+              $$ ppWhen (token == "<-")+                        (if mdoInLast100+                           then text "Perhaps you intended to use RecursiveDo"+                           else text "Perhaps this statement should be within a 'do' block?")+              $$ ppWhen (token == "=" && doInLast100) -- #15849+                        (text "Perhaps you need a 'let' in a 'do' block?"+                         $$ text "e.g. 'let x = 5' instead of 'x = 5'")+              $$ ppWhen (not ps_enabled && pattern == "pattern ") -- #12429+                        (text "Perhaps you intended to use PatternSynonyms")+  where token = lexemeToString (offsetBytes (-len) buf) len+        pattern = decodePrevNChars 8 buf+        last100 = decodePrevNChars 100 buf+        doInLast100 = "do" `isInfixOf` last100+        mdoInLast100 = "mdo" `isInfixOf` last100+        th_enabled = ThQuotesBit `xtest` pExtsBitmap options+        ps_enabled = PatternSynonymsBit `xtest` pExtsBitmap options++-- Report a parse failure, giving the span of the previous token as+-- the location of the error.  This is the entry point for errors+-- detected during parsing.+srcParseFail :: P a+srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len,+                            last_loc = last_loc } ->+    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.+lexError :: String -> P a+lexError str = do+  loc <- getRealSrcLoc+  (AI end buf) <- getInput+  reportLexError loc (psRealLoc end) buf str++-- -----------------------------------------------------------------------------+-- This is the top-level function: called from the parser each time a+-- new token is to be read from the input.++lexer, lexerDbg :: Bool -> (Located Token -> P a) -> P a++lexer queueComments cont = do+  alr <- getBit AlternativeLayoutRuleBit+  let lexTokenFun = if alr then lexTokenAlr else lexToken+  (L span tok) <- lexTokenFun+  --trace ("token: " ++ show tok) $ do++  if (queueComments && isDocComment tok)+    then queueComment (L (psRealSpan span) tok)+    else return ()++  if (queueComments && isComment tok)+    then queueComment (L (psRealSpan span) tok) >> lexer queueComments cont+    else cont (L (mkSrcSpanPs span) tok)++-- Use this instead of 'lexer' in GHC.Parser to dump the tokens for debugging.+lexerDbg queueComments cont = lexer queueComments contDbg+  where+    contDbg tok = trace ("token: " ++ show (unLoc tok)) (cont tok)++lexTokenAlr :: P (PsLocated Token)+lexTokenAlr = do mPending <- popPendingImplicitToken+                 t <- case mPending of+                      Nothing ->+                          do mNext <- popNextToken+                             t <- case mNext of+                                  Nothing -> lexToken+                                  Just next -> return next+                             alternativeLayoutRuleToken t+                      Just t ->+                          return t+                 setAlrLastLoc (getLoc t)+                 case unLoc t of+                     ITwhere -> setAlrExpectingOCurly (Just ALRLayoutWhere)+                     ITlet   -> setAlrExpectingOCurly (Just ALRLayoutLet)+                     ITof    -> setAlrExpectingOCurly (Just ALRLayoutOf)+                     ITlcase -> setAlrExpectingOCurly (Just ALRLayoutOf)+                     ITdo    -> setAlrExpectingOCurly (Just ALRLayoutDo)+                     ITmdo   -> setAlrExpectingOCurly (Just ALRLayoutDo)+                     ITrec   -> setAlrExpectingOCurly (Just ALRLayoutDo)+                     _       -> return ()+                 return t++alternativeLayoutRuleToken :: PsLocated Token -> P (PsLocated Token)+alternativeLayoutRuleToken t+    = do context <- getALRContext+         lastLoc <- getAlrLastLoc+         mExpectingOCurly <- getAlrExpectingOCurly+         transitional <- getBit ALRTransitionalBit+         justClosedExplicitLetBlock <- getJustClosedExplicitLetBlock+         setJustClosedExplicitLetBlock False+         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) ->+                 do setAlrExpectingOCurly Nothing+                    let isLet = case alrLayout of+                                ALRLayoutLet -> True+                                _ -> False+                    setALRContext (ALRNoLayout (containsCommas ITocurly) isLet : context)+                    return t+             -- ...and makes this case unnecessary+             {-+             -- I think our implicit open-curly handling is slightly+             -- different to John's, in how it interacts with newlines+             -- and "in"+             (ITocurly, _, Just _) ->+                 do setAlrExpectingOCurly Nothing+                    setNextToken t+                    lexTokenAlr+             -}+             (_, ALRLayout _ col : _ls, Just expectingOCurly)+              | (thisCol > col) ||+                (thisCol == col &&+                 isNonDecreasingIndentation expectingOCurly) ->+                 do setAlrExpectingOCurly Nothing+                    setALRContext (ALRLayout expectingOCurly thisCol : context)+                    setNextToken t+                    return (L thisLoc ITvocurly)+              | otherwise ->+                 do setAlrExpectingOCurly Nothing+                    setPendingImplicitTokens [L lastLoc ITvccurly]+                    setNextToken t+                    return (L lastLoc ITvocurly)+             (_, _, Just expectingOCurly) ->+                 do setAlrExpectingOCurly Nothing+                    setALRContext (ALRLayout expectingOCurly thisCol : context)+                    setNextToken t+                    return (L thisLoc ITvocurly)+             -- We do the [] cases earlier than in the spec, as we+             -- have an actual EOF token+             (ITeof, ALRLayout _ _ : ls, _) ->+                 do setALRContext ls+                    setNextToken t+                    return (L thisLoc ITvccurly)+             (ITeof, _, _) ->+                 return t+             -- the other ITeof case omitted; general case below covers it+             (ITin, _, _)+              | justClosedExplicitLetBlock ->+                 return t+             (ITin, ALRLayout ALRLayoutLet _ : ls, _)+              | newLine ->+                 do setPendingImplicitTokens [t]+                    setALRContext ls+                    return (L thisLoc ITvccurly)+             -- This next case is to handle a transitional issue:+             (ITwhere, ALRLayout _ col : ls, _)+              | newLine && thisCol == col && transitional ->+                 do addWarning Opt_WarnAlternativeLayoutRuleTransitional+                               (mkSrcSpanPs thisLoc)+                               (transitionalAlternativeLayoutWarning+                                    "`where' clause at the same depth as implicit layout block")+                    setALRContext ls+                    setNextToken t+                    -- Note that we use lastLoc, as we may need to close+                    -- more layouts, or give a semicolon+                    return (L lastLoc ITvccurly)+             -- This next case is to handle a transitional issue:+             (ITvbar, ALRLayout _ col : ls, _)+              | newLine && thisCol == col && transitional ->+                 do addWarning Opt_WarnAlternativeLayoutRuleTransitional+                               (mkSrcSpanPs thisLoc)+                               (transitionalAlternativeLayoutWarning+                                    "`|' at the same depth as implicit layout block")+                    setALRContext ls+                    setNextToken t+                    -- Note that we use lastLoc, as we may need to close+                    -- more layouts, or give a semicolon+                    return (L lastLoc ITvccurly)+             (_, ALRLayout _ col : ls, _)+              | newLine && thisCol == col ->+                 do setNextToken t+                    let loc = psSpanStart thisLoc+                        zeroWidthLoc = mkPsSpan loc loc+                    return (L zeroWidthLoc ITsemi)+              | newLine && thisCol < col ->+                 do setALRContext ls+                    setNextToken t+                    -- Note that we use lastLoc, as we may need to close+                    -- more layouts, or give a semicolon+                    return (L lastLoc ITvccurly)+             -- We need to handle close before open, as 'then' is both+             -- an open and a close+             (u, _, _)+              | isALRclose u ->+                 case context of+                 ALRLayout _ _ : ls ->+                     do setALRContext ls+                        setNextToken t+                        return (L thisLoc ITvccurly)+                 ALRNoLayout _ isLet : ls ->+                     do let ls' = if isALRopen u+                                     then ALRNoLayout (containsCommas u) False : ls+                                     else ls+                        setALRContext ls'+                        when isLet $ setJustClosedExplicitLetBlock True+                        return t+                 [] ->+                     do let ls = if isALRopen u+                                    then [ALRNoLayout (containsCommas u) False]+                                    else []+                        setALRContext ls+                        -- XXX This is an error in John's code, but+                        -- it looks reachable to me at first glance+                        return t+             (u, _, _)+              | isALRopen u ->+                 do setALRContext (ALRNoLayout (containsCommas u) False : context)+                    return t+             (ITin, ALRLayout ALRLayoutLet _ : ls, _) ->+                 do setALRContext ls+                    setPendingImplicitTokens [t]+                    return (L thisLoc ITvccurly)+             (ITin, ALRLayout _ _ : ls, _) ->+                 do setALRContext ls+                    setNextToken t+                    return (L thisLoc ITvccurly)+             -- the other ITin case omitted; general case below covers it+             (ITcomma, ALRLayout _ _ : ls, _)+              | topNoLayoutContainsCommas ls ->+                 do setALRContext ls+                    setNextToken t+                    return (L thisLoc ITvccurly)+             (ITwhere, ALRLayout ALRLayoutDo _ : ls, _) ->+                 do setALRContext ls+                    setPendingImplicitTokens [t]+                    return (L thisLoc ITvccurly)+             -- the other ITwhere case omitted; general case below covers it+             (_, _, _) -> return t++transitionalAlternativeLayoutWarning :: String -> SDoc+transitionalAlternativeLayoutWarning msg+    = text "transitional layout will not be accepted in the future:"+   $$ text msg++isALRopen :: Token -> Bool+isALRopen ITcase          = True+isALRopen ITif            = True+isALRopen ITthen          = True+isALRopen IToparen        = True+isALRopen ITobrack        = True+isALRopen ITocurly        = True+-- GHC Extensions:+isALRopen IToubxparen     = True+isALRopen _               = False++isALRclose :: Token -> Bool+isALRclose ITof     = True+isALRclose ITthen   = True+isALRclose ITelse   = True+isALRclose ITcparen = True+isALRclose ITcbrack = True+isALRclose ITccurly = True+-- GHC Extensions:+isALRclose ITcubxparen = True+isALRclose _        = False++isNonDecreasingIndentation :: ALRLayout -> Bool+isNonDecreasingIndentation ALRLayoutDo = True+isNonDecreasingIndentation _           = False++containsCommas :: Token -> Bool+containsCommas IToparen = True+containsCommas ITobrack = True+-- John doesn't have {} as containing commas, but records contain them,+-- which caused a problem parsing Cabal's Distribution.Simple.InstallDirs+-- (defaultInstallDirs).+containsCommas ITocurly = True+-- GHC Extensions:+containsCommas IToubxparen = True+containsCommas _        = False++topNoLayoutContainsCommas :: [ALRContext] -> Bool+topNoLayoutContainsCommas [] = False+topNoLayoutContainsCommas (ALRLayout _ _ : ls) = topNoLayoutContainsCommas ls+topNoLayoutContainsCommas (ALRNoLayout b _ : _) = b++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 = mkPsSpan loc1 loc1+        setEofPos (psRealSpan span)+        setLastToken span 0+        return (L span ITeof)+    AlexError (AI loc2 buf) ->+        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 = mkPsSpan loc1 end+        let bytes = byteDiff buf buf2+        span `seq` setLastToken span bytes+        lt <- t span buf bytes+        let lt' = unLoc lt+        unless (isComment lt') (setLastTk lt')+        return lt++reportLexError :: RealSrcLoc -> RealSrcLoc -> StringBuffer -> [Char] -> P a+reportLexError loc1 loc2 buf str+  | atEnd buf = failLocMsgP loc1 loc2 (str ++ " at end of input")+  | otherwise =+  let c = fst (nextChar buf)+  in if c == '\0' -- decoding errors are mapped to '\0', see utf8DecodeChar#+     then failLocMsgP loc2 loc2 (str ++ " (UTF-8 decoding error)")+     else failLocMsgP loc1 loc2 (str ++ " at character " ++ show c)++lexTokenStream :: StringBuffer -> RealSrcLoc -> DynFlags -> ParseResult [Located Token]+lexTokenStream buf loc dflags = unP go initState{ options = opts' }+    where dflags' = gopt_set (gopt_unset dflags Opt_Haddock) Opt_KeepRawTokenStream+          initState@PState{ options = opts } = mkPState dflags' buf loc+          opts' = opts{ pExtsBitmap = complement (xbit UsePosPragsBit) .&. pExtsBitmap opts }+          go = do+            ltok <- lexer False return+            case ltok of+              L _ ITeof -> return []+              _ -> liftM (ltok:) go++linePrags = Map.singleton "line" linePrag++fileHeaderPrags = Map.fromList([("options", lex_string_prag IToptions_prag),+                                 ("options_ghc", lex_string_prag IToptions_prag),+                                 ("options_haddock", lex_string_prag ITdocOptions),+                                 ("language", token ITlanguage_prag),+                                 ("include", lex_string_prag ITinclude_prag)])++ignoredPrags = Map.fromList (map ignored pragmas)+               where ignored opt = (opt, nested_comment lexToken)+                     impls = ["hugs", "nhc98", "jhc", "yhc", "catch", "derive"]+                     options_pragmas = map ("options_" ++) impls+                     -- CFILES is a hugs-only thing.+                     pragmas = options_pragmas ++ ["cfiles", "contract"]++oneWordPrags = Map.fromList [+     ("rules", rulePrag),+     ("inline",+         strtoken (\s -> (ITinline_prag (SourceText s) Inline FunLike))),+     ("inlinable",+         strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),+     ("inlineable",+         strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),+                                    -- Spelling variant+     ("notinline",+         strtoken (\s -> (ITinline_prag (SourceText s) NoInline FunLike))),+     ("specialize", strtoken (\s -> ITspec_prag (SourceText s))),+     ("source", strtoken (\s -> ITsource_prag (SourceText s))),+     ("warning", strtoken (\s -> ITwarning_prag (SourceText s))),+     ("deprecated", strtoken (\s -> ITdeprecated_prag (SourceText s))),+     ("scc", strtoken (\s -> ITscc_prag (SourceText s))),+     ("generated", strtoken (\s -> ITgenerated_prag (SourceText s))),+     ("core", strtoken (\s -> ITcore_prag (SourceText s))),+     ("unpack", strtoken (\s -> ITunpack_prag (SourceText s))),+     ("nounpack", strtoken (\s -> ITnounpack_prag (SourceText s))),+     ("ann", strtoken (\s -> ITann_prag (SourceText s))),+     ("minimal", strtoken (\s -> ITminimal_prag (SourceText s))),+     ("overlaps", strtoken (\s -> IToverlaps_prag (SourceText s))),+     ("overlappable", strtoken (\s -> IToverlappable_prag (SourceText s))),+     ("overlapping", strtoken (\s -> IToverlapping_prag (SourceText s))),+     ("incoherent", strtoken (\s -> ITincoherent_prag (SourceText s))),+     ("ctype", strtoken (\s -> ITctype (SourceText s))),+     ("complete", strtoken (\s -> ITcomplete_prag (SourceText s))),+     ("column", columnPrag)+     ]++twoWordPrags = Map.fromList [+     ("inline conlike",+         strtoken (\s -> (ITinline_prag (SourceText s) Inline ConLike))),+     ("notinline conlike",+         strtoken (\s -> (ITinline_prag (SourceText s) NoInline ConLike))),+     ("specialize inline",+         strtoken (\s -> (ITspec_inline_prag (SourceText s) True))),+     ("specialize notinline",+         strtoken (\s -> (ITspec_inline_prag (SourceText s) False)))+     ]++dispatch_pragmas :: Map String Action -> Action+dispatch_pragmas prags span buf len = case Map.lookup (clean_pragma (lexemeToString buf len)) prags of+                                       Just found -> found span buf len+                                       Nothing -> lexError "unknown pragma"++known_pragma :: Map String Action -> AlexAccPred ExtsBitmap+known_pragma prags _ (AI _ startbuf) _ (AI _ curbuf)+ = isKnown && nextCharIsNot curbuf pragmaNameChar+    where l = lexemeToString startbuf (byteDiff startbuf curbuf)+          isKnown = isJust $ Map.lookup (clean_pragma l) prags+          pragmaNameChar c = isAlphaNum c || c == '_'++clean_pragma :: String -> String+clean_pragma prag = canon_ws (map toLower (unprefix prag))+                    where unprefix prag' = case stripPrefix "{-#" prag' of+                                             Just rest -> rest+                                             Nothing -> prag'+                          canonical prag' = case prag' of+                                              "noinline" -> "notinline"+                                              "specialise" -> "specialize"+                                              "constructorlike" -> "conlike"+                                              _ -> prag'+                          canon_ws s = unwords (map canonical (words s))++++{-+%************************************************************************+%*                                                                      *+        Helper functions for generating annotations in the parser+%*                                                                      *+%************************************************************************+-}++-- | Encapsulated call to addAnnotation, requiring only the SrcSpan of+--   the AST construct the annotation belongs to; together with the+--   AnnKeywordId, this is the key of the annotation map.+--+--   This type is useful for places in the parser where it is not yet+--   known what SrcSpan an annotation should be added to.  The most+--   common situation is when we are parsing a list: the annotations+--   need to be associated with the AST element that *contains* the+--   list, not the list itself.  'AddAnn' lets us defer adding the+--   annotations until we finish parsing the list and are now parsing+--   the enclosing element; we then apply the 'AddAnn' to associate+--   the annotations.  Another common situation is where a common fragment of+--   the AST has been factored out but there is no separate AST node for+--   this fragment (this occurs in class and data declarations). In this+--   case, the annotation belongs to the parent data declaration.+--+--   The usual way an 'AddAnn' is created is using the 'mj' ("make jump")+--   function, and then it can be discharged using the 'ams' function.+data AddAnn = AddAnn AnnKeywordId SrcSpan++addAnnotationOnly :: RealSrcSpan -> AnnKeywordId -> RealSrcSpan -> P ()+addAnnotationOnly l a v = P $ \s -> POk s {+  annotations = ((l,a), [v]) : annotations s+  } ()++-- |Given a 'SrcSpan' that surrounds a 'HsPar' or 'HsParTy', generate+-- 'AddAnn' values for the opening and closing bordering on the start+-- and end of the span+mkParensApiAnn :: SrcSpan -> [AddAnn]+mkParensApiAnn (UnhelpfulSpan _)  = []+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 = RealSrcSpan (mkRealSrcSpan (realSrcSpanStart ss)        (mkRealSrcLoc f sl (sc+1))) Nothing+    lc = RealSrcSpan (mkRealSrcSpan (mkRealSrcLoc f el (ec - 1)) (realSrcSpanEnd ss))        Nothing++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 :: RealSrcSpan -> P ()+allocateCommentsP ss = P $ \s ->+  let (comment_q', newAnns) = allocateComments ss (comment_q s) in+    POk s {+       comment_q = comment_q'+     , annotations_comments = newAnns ++ (annotations_comments s)+     } ()++allocateComments+  :: RealSrcSpan+  -> [RealLocated AnnotationComment]+  -> ([RealLocated AnnotationComment], [(RealSrcSpan,[RealLocated AnnotationComment])])+allocateComments ss comment_q =+  let+    (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)]+  in+    (comment_q', newAnns)+++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)+commentToAnnotation (L l (ITdocSection n s))    = L l (AnnDocSection n s)+commentToAnnotation (L l (ITdocOptions s))      = L l (AnnDocOptions s)+commentToAnnotation (L l (ITlineComment s))     = L l (AnnLineComment s)+commentToAnnotation (L l (ITblockComment s))    = L l (AnnBlockComment s)+commentToAnnotation _                           = panic "commentToAnnotation"++-- ---------------------------------------------------------------------++isComment :: Token -> Bool+isComment (ITlineComment     _)   = True+isComment (ITblockComment    _)   = True+isComment _ = False++isDocComment :: Token -> Bool+isDocComment (ITdocCommentNext  _)   = True+isDocComment (ITdocCommentPrev  _)   = True+isDocComment (ITdocCommentNamed _)   = True+isDocComment (ITdocSection      _ _) = True+isDocComment (ITdocOptions      _)   = True+isDocComment _ = False+++bol,column_prag,layout,layout_do,layout_if,layout_left,line_prag1,line_prag1a,line_prag2,line_prag2a,option_prags :: Int+bol = 1+column_prag = 2+layout = 3+layout_do = 4+layout_if = 5+layout_left = 6+line_prag1 = 7+line_prag1a = 8+line_prag2 = 9+line_prag2a = 10+option_prags = 11+alex_action_1 =  warnTab +alex_action_2 =  nested_comment lexToken +alex_action_3 =  lineCommentToken +alex_action_4 =  lineCommentToken +alex_action_5 =  lineCommentToken +alex_action_6 =  lineCommentToken +alex_action_7 =  lineCommentToken +alex_action_8 =  lineCommentToken +alex_action_10 =  begin line_prag1 +alex_action_11 =  begin line_prag1 +alex_action_14 =  do_bol +alex_action_15 =  hopefully_open_brace +alex_action_17 =  begin line_prag1 +alex_action_18 =  new_layout_context True dontGenerateSemic ITvbar +alex_action_19 =  pop +alex_action_20 =  new_layout_context True  generateSemic ITvocurly +alex_action_21 =  new_layout_context False generateSemic ITvocurly +alex_action_22 =  do_layout_left +alex_action_23 =  begin bol +alex_action_24 =  dispatch_pragmas linePrags +alex_action_25 =  setLineAndFile line_prag1a +alex_action_26 =  failLinePrag1 +alex_action_27 =  popLinePrag1 +alex_action_28 =  setLineAndFile line_prag2a +alex_action_29 =  pop +alex_action_30 =  setColumn +alex_action_31 =  dispatch_pragmas twoWordPrags +alex_action_32 =  dispatch_pragmas oneWordPrags +alex_action_33 =  dispatch_pragmas ignoredPrags +alex_action_34 =  endPrag +alex_action_35 =  dispatch_pragmas fileHeaderPrags +alex_action_36 =  nested_comment lexToken +alex_action_37 =  warnThen Opt_WarnUnrecognisedPragmas (text "Unrecognised pragma")+                    (nested_comment lexToken) +alex_action_38 =  multiline_doc_comment +alex_action_39 =  nested_doc_comment +alex_action_40 =  token (ITopenExpQuote NoE NormalSyntax) +alex_action_41 =  token (ITopenTExpQuote NoE) +alex_action_42 =  token (ITopenExpQuote HasE NormalSyntax) +alex_action_43 =  token (ITopenTExpQuote HasE) +alex_action_44 =  token ITopenPatQuote +alex_action_45 =  layout_token ITopenDecQuote +alex_action_46 =  token ITopenTypQuote +alex_action_47 =  token (ITcloseQuote NormalSyntax) +alex_action_48 =  token ITcloseTExpQuote +alex_action_49 =  lex_quasiquote_tok +alex_action_50 =  lex_qquasiquote_tok +alex_action_51 =  token (ITopenExpQuote NoE UnicodeSyntax) +alex_action_52 =  token (ITcloseQuote UnicodeSyntax) +alex_action_53 =  special (IToparenbar NormalSyntax) +alex_action_54 =  special (ITcparenbar NormalSyntax) +alex_action_55 =  special (IToparenbar UnicodeSyntax) +alex_action_56 =  special (ITcparenbar UnicodeSyntax) +alex_action_57 =  skip_one_varid ITdupipvarid +alex_action_58 =  skip_one_varid ITlabelvarid +alex_action_59 =  token IToubxparen +alex_action_60 =  token ITcubxparen +alex_action_61 =  special IToparen +alex_action_62 =  special ITcparen +alex_action_63 =  special ITobrack +alex_action_64 =  special ITcbrack +alex_action_65 =  special ITcomma +alex_action_66 =  special ITsemi +alex_action_67 =  special ITbackquote +alex_action_68 =  open_brace +alex_action_69 =  close_brace +alex_action_70 =  idtoken qvarid +alex_action_71 =  idtoken qconid +alex_action_72 =  varid +alex_action_73 =  idtoken conid +alex_action_74 =  idtoken qvarid +alex_action_75 =  idtoken qconid +alex_action_76 =  varid +alex_action_77 =  idtoken conid +alex_action_78 =  varsym_tight_infix +alex_action_79 =  varsym_prefix +alex_action_80 =  varsym_suffix +alex_action_81 =  varsym_loose_infix +alex_action_82 =  idtoken qvarsym +alex_action_83 =  idtoken qconsym +alex_action_84 =  consym +alex_action_85 =  tok_num positive 0 0 decimal +alex_action_86 =  tok_num positive 2 2 binary +alex_action_87 =  tok_num positive 2 2 octal +alex_action_88 =  tok_num positive 2 2 hexadecimal +alex_action_89 =  tok_num negative 1 1 decimal +alex_action_90 =  tok_num negative 3 3 binary +alex_action_91 =  tok_num negative 3 3 octal +alex_action_92 =  tok_num negative 3 3 hexadecimal +alex_action_93 =  tok_frac 0 tok_float +alex_action_94 =  tok_frac 0 tok_float +alex_action_95 =  tok_frac 0 tok_hex_float +alex_action_96 =  tok_frac 0 tok_hex_float +alex_action_97 =  tok_primint positive 0 1 decimal +alex_action_98 =  tok_primint positive 2 3 binary +alex_action_99 =  tok_primint positive 2 3 octal +alex_action_100 =  tok_primint positive 2 3 hexadecimal +alex_action_101 =  tok_primint negative 1 2 decimal +alex_action_102 =  tok_primint negative 3 4 binary +alex_action_103 =  tok_primint negative 3 4 octal +alex_action_104 =  tok_primint negative 3 4 hexadecimal +alex_action_105 =  tok_primword 0 2 decimal +alex_action_106 =  tok_primword 2 4 binary +alex_action_107 =  tok_primword 2 4 octal +alex_action_108 =  tok_primword 2 4 hexadecimal +alex_action_109 =  tok_frac 1 tok_primfloat +alex_action_110 =  tok_frac 2 tok_primdouble +alex_action_111 =  lex_char_tok +alex_action_112 =  lex_string_tok +{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- -----------------------------------------------------------------------------+-- ALEX TEMPLATE+--+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use+-- it for any purpose whatsoever.++-- -----------------------------------------------------------------------------+-- INTERNALS and main scanner engine++++++++++++++++++-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ > 706+#define GTE(n,m) (tagToEnum# (n >=# m))+#define EQ(n,m) (tagToEnum# (n ==# m))+#else+#define GTE(n,m) (n >=# m)+#define EQ(n,m) (n ==# m)+#endif++++++++++++++++++++data AlexAddr = AlexA# Addr#+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ < 503+uncheckedShiftL# = shiftL#+#endif++{-# INLINE alexIndexInt16OffAddr #-}+alexIndexInt16OffAddr (AlexA# arr) off =+#ifdef WORDS_BIGENDIAN+  narrow16Int# i+  where+        i    = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)+        high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+        low  = int2Word# (ord# (indexCharOffAddr# arr off'))+        off' = off *# 2#+#else+  indexInt16OffAddr# arr off+#endif++++++{-# INLINE alexIndexInt32OffAddr #-}+alexIndexInt32OffAddr (AlexA# arr) off =+#ifdef WORDS_BIGENDIAN+  narrow32Int# i+  where+   i    = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`+                     (b2 `uncheckedShiftL#` 16#) `or#`+                     (b1 `uncheckedShiftL#` 8#) `or#` b0)+   b3   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))+   b2   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))+   b1   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+   b0   = int2Word# (ord# (indexCharOffAddr# arr off'))+   off' = off *# 4#+#else+  indexInt32OffAddr# arr off+#endif+++++++#if __GLASGOW_HASKELL__ < 503+quickIndex arr i = arr ! i+#else+-- GHC >= 503, unsafeAt is available from Data.Array.Base.+quickIndex = unsafeAt+#endif+++++-- -----------------------------------------------------------------------------+-- Main lexing routines++data AlexReturn a+  = AlexEOF+  | AlexError  !AlexInput+  | AlexSkip   !AlexInput !Int+  | AlexToken  !AlexInput !Int a++-- alexScan :: AlexInput -> StartCode -> AlexReturn a+alexScan input__ (I# (sc))+  = alexScanUser undefined input__ (I# (sc))++alexScanUser user__ input__ (I# (sc))+  = case alex_scan_tkn user__ input__ 0# input__ sc AlexNone of+  (AlexNone, input__') ->+    case alexGetByte input__ of+      Nothing ->++++                                   AlexEOF+      Just _ ->++++                                   AlexError input__'++  (AlexLastSkip input__'' len, _) ->++++    AlexSkip input__'' len++  (AlexLastAcc k input__''' len, _) ->++++    AlexToken input__''' len (alex_actions ! k)+++-- Push the input through the DFA, remembering the most recent accepting+-- state it encountered.++alex_scan_tkn user__ orig_input len input__ s last_acc =+  input__ `seq` -- strict in the input+  let+  new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))+  in+  new_acc `seq`+  case alexGetByte input__ of+     Nothing -> (new_acc, input__)+     Just (c, new_input) ->++++      case fromIntegral c of { (I# (ord_c)) ->+        let+                base   = alexIndexInt32OffAddr alex_base s+                offset = (base +# ord_c)+                check  = alexIndexInt16OffAddr alex_check offset++                new_s = if GTE(offset,0#) && EQ(check,ord_c)+                          then alexIndexInt16OffAddr alex_table offset+                          else alexIndexInt16OffAddr alex_deflt s+        in+        case new_s of+            -1# -> (new_acc, input__)+                -- on an error, we want to keep the input *before* the+                -- character that failed, not after.+            _ -> alex_scan_tkn user__ orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)+                                                -- note that the length is increased ONLY if this is the 1st byte in a char encoding)+                        new_input new_s new_acc+      }+  where+        check_accs (AlexAccNone) = last_acc+        check_accs (AlexAcc a  ) = AlexLastAcc a input__ (I# (len))+        check_accs (AlexAccSkip) = AlexLastSkip  input__ (I# (len))++        check_accs (AlexAccPred a predx rest)+           | predx user__ orig_input (I# (len)) input__+           = AlexLastAcc a input__ (I# (len))+           | otherwise+           = check_accs rest+        check_accs (AlexAccSkipPred predx rest)+           | predx user__ orig_input (I# (len)) input__+           = AlexLastSkip input__ (I# (len))+           | otherwise+           = check_accs rest+++data AlexLastAcc+  = AlexNone+  | AlexLastAcc !Int !AlexInput !Int+  | AlexLastSkip     !AlexInput !Int++data AlexAcc user+  = AlexAccNone+  | AlexAcc Int+  | AlexAccSkip++  | AlexAccPred Int (AlexAccPred user) (AlexAcc user)+  | AlexAccSkipPred (AlexAccPred user) (AlexAcc user)++type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool++-- -----------------------------------------------------------------------------+-- Predicates on a rule++alexAndPred p1 p2 user__ in1 len in2+  = p1 user__ in1 len in2 && p2 user__ in1 len in2++--alexPrevCharIsPred :: Char -> AlexAccPred _+alexPrevCharIs c _ input__ _ _ = c == alexInputPrevChar input__++alexPrevCharMatches f _ input__ _ _ = f (alexInputPrevChar input__)++--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _+alexPrevCharIsOneOf arr _ input__ _ _ = arr ! alexInputPrevChar input__++--alexRightContext :: Int -> AlexAccPred _+alexRightContext (I# (sc)) user__ _ _ input__ =+     case alex_scan_tkn user__ input__ 0# input__ sc AlexNone of+          (AlexNone, _) -> False+          _ -> True+        -- TODO: there's no need to find the longest+        -- match when checking the right context, just+        -- the first match will do.+
− ghc-lib/stage0/compiler/build/Lexer.hs 
@@ -1,3568 +0,0 @@-{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-missing-signatures #-}-{-# LANGUAGE CPP,MagicHash #-}-{-# LINE 43 "compiler/parser/Lexer.x" #-}--{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE LambdaCase #-}-{-# LANGUAGE MultiWayIf #-}--{-# OPTIONS_GHC -funbox-strict-fields #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}--module Lexer (-   Token(..), lexer, lexerDbg, pragState, mkPState, mkPStatePure, PState(..),-   P(..), ParseResult(..), mkParserFlags, mkParserFlags', ParserFlags(..),-   appendWarning,-   appendError,-   allocateComments,-   MonadP(..),-   getRealSrcLoc, getPState, withThisPackage,-   failMsgP, failLocMsgP, srcParseFail,-   getErrorMessages, getMessages,-   popContext, pushModuleContext, setLastToken, setSrcLoc,-   activeContext, nextIsEOF,-   getLexState, popLexState, pushLexState,-   ExtBits(..),-   xtest,-   lexTokenStream,-   AddAnn(..),mkParensApiAnn,-   addAnnsAt,-   commentToAnnotation-  ) where--import GhcPrelude---- base-import Control.Monad-import Data.Bits-import Data.Char-import Data.List-import Data.Maybe-import Data.Word--import EnumSet (EnumSet)-import qualified EnumSet---- ghc-boot-import qualified GHC.LanguageExtensions as LangExt---- bytestring-import Data.ByteString (ByteString)---- containers-import Data.Map (Map)-import qualified Data.Map as Map---- compiler/utils-import Bag-import Outputable-import StringBuffer-import FastString-import GHC.Types.Unique.FM-import Util             ( readRational, readHexRational )---- compiler/main-import ErrUtils-import GHC.Driver.Session as DynFlags---- compiler/basicTypes-import GHC.Types.SrcLoc-import GHC.Types.Module-import GHC.Types.Basic ( InlineSpec(..), RuleMatchInfo(..),-                         IntegralLit(..), FractionalLit(..),-                         SourceText(..) )---- compiler/parser-import Ctype--import ApiAnnotation--#if __GLASGOW_HASKELL__ >= 603-#include "ghcconfig.h"-#elif defined(__GLASGOW_HASKELL__)-#include "config.h"-#endif-#if __GLASGOW_HASKELL__ >= 503-import Data.Array-#else-import Array-#endif-#if __GLASGOW_HASKELL__ >= 503-import Data.Array.Base (unsafeAt)-import GHC.Exts-#else-import GlaExts-#endif-alex_tab_size :: Int-alex_tab_size = 8-alex_base :: AlexAddr-alex_base = AlexA#-  "\x01\x00\x00\x00\x7b\x00\x00\x00\x84\x00\x00\x00\xa0\x00\x00\x00\xbc\x00\x00\x00\xc5\x00\x00\x00\xce\x00\x00\x00\xec\x00\x00\x00\x06\x01\x00\x00\x22\x01\x00\x00\x3f\x01\x00\x00\x7b\x01\x00\x00\xd4\xff\xff\xff\x61\x00\x00\x00\xd7\xff\xff\xff\xdb\xff\xff\xff\xa4\xff\xff\xff\xaa\xff\xff\xff\xf8\x01\x00\x00\x72\x02\x00\x00\xec\x02\x00\x00\x93\xff\xff\xff\x94\xff\xff\xff\x66\x03\x00\x00\x95\xff\xff\xff\xb2\xff\xff\xff\xe7\xff\xff\xff\xe8\xff\xff\xff\xe9\xff\xff\xff\xd1\x00\x00\x00\xae\xff\xff\xff\xab\xff\xff\xff\xb0\xff\xff\xff\x59\x01\x00\x00\xdc\x03\x00\x00\xfc\x01\x00\x00\xe6\x03\x00\x00\xb3\xff\xff\xff\xba\xff\xff\xff\xac\xff\xff\xff\x3d\x01\x00\x00\x7a\x01\x00\x00\x50\x02\x00\x00\xca\x02\x00\x00\x1f\x04\x00\x00\xfa\x03\x00\x00\x59\x04\x00\x00\x95\x01\x00\x00\x05\x02\x00\x00\xaf\xff\xff\xff\xb1\xff\xff\xff\xa4\x04\x00\x00\xe5\x04\x00\x00\x63\x02\x00\x00\x44\x03\x00\x00\xdd\x02\x00\x00\xfc\x04\x00\x00\x3d\x05\x00\x00\x57\x03\x00\x00\xc5\x04\x00\x00\x1d\x05\x00\x00\x59\x05\x00\x00\x63\x05\x00\x00\x79\x05\x00\x00\x83\x05\x00\x00\x99\x05\x00\x00\xa9\x05\x00\x00\xb3\x05\x00\x00\xbd\x05\x00\x00\xc9\x05\x00\x00\xd3\x05\x00\x00\xed\x05\x00\x00\x04\x06\x00\x00\x63\x00\x00\x00\x51\x00\x00\x00\x26\x06\x00\x00\x4b\x06\x00\x00\x62\x06\x00\x00\xc4\x03\x00\x00\x6c\x00\x00\x00\x84\x06\x00\x00\xbd\x06\x00\x00\x17\x07\x00\x00\x95\x07\x00\x00\x11\x08\x00\x00\x8d\x08\x00\x00\x09\x09\x00\x00\x85\x09\x00\x00\x01\x0a\x00\x00\xb9\x00\x00\x00\x7d\x0a\x00\x00\xfb\x0a\x00\x00\x12\x00\x00\x00\x16\x00\x00\x00\x2d\x01\x00\x00\x5e\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\xfa\x01\x00\x00\xe0\x03\x00\x00\x67\x00\x00\x00\x9c\x00\x00\x00\x81\x00\x00\x00\x82\x00\x00\x00\x88\x00\x00\x00\x95\x00\x00\x00\x96\x00\x00\x00\x97\x00\x00\x00\x76\x0b\x00\x00\x9e\x0b\x00\x00\xe1\x0b\x00\x00\x09\x0c\x00\x00\x4c\x0c\x00\x00\x74\x0c\x00\x00\xb7\x0c\x00\x00\xe7\x04\x00\x00\x94\x07\x00\x00\x10\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x0c\x00\x00\x71\x0d\x00\x00\xeb\x0d\x00\x00\x65\x0e\x00\x00\xdf\x0e\x00\x00\xa8\x00\x00\x00\xa9\x00\x00\x00\x5d\x0f\x00\x00\x9d\x00\x00\x00\xd7\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x10\x00\x00\x00\x00\x00\x00\xcf\x10\x00\x00\x49\x11\x00\x00\x00\x00\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x11\x00\x00\x3d\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\xf3\x12\x00\x00\x6d\x13\x00\x00\xe7\x13\x00\x00\x61\x14\x00\x00\xdb\x14\x00\x00\x55\x15\x00\x00\xcf\x15\x00\x00\x49\x16\x00\x00\xc3\x16\x00\x00\x3d\x17\x00\x00\xb7\x17\x00\x00\x31\x18\x00\x00\xab\x18\x00\x00\x25\x19\x00\x00\xa1\x00\x00\x00\xbd\x00\x00\x00\xbe\x00\x00\x00\xbf\x00\x00\x00\xc1\x00\x00\x00\xc3\x00\x00\x00\x7f\x19\x00\x00\xa7\x19\x00\x00\xca\x19\x00\x00\xf2\x19\x00\x00\x35\x1a\x00\x00\x5a\x1a\x00\x00\xd3\x1a\x00\x00\x2f\x1b\x00\x00\x52\x1b\x00\x00\x75\x1b\x00\x00\x58\x0b\x00\x00\x93\x1b\x00\x00\xdd\x00\x00\x00\xbb\x06\x00\x00\xdc\x1b\x00\x00\xb6\x1a\x00\x00\x01\x1c\x00\x00\x20\x01\x00\x00\x71\x07\x00\x00\x4a\x1c\x00\x00\x6e\x1c\x00\x00\xf2\x07\x00\x00\x8f\x1c\x00\x00\x6e\x08\x00\x00\xa5\x1c\x00\x00\xe4\x08\x00\x00\xe6\x1c\x00\x00\x60\x09\x00\x00\xc4\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--alex_table :: AlexAddr-alex_table = AlexA#-  "\x00\x00\x64\x00\xbc\x00\xb5\x00\x6d\x00\xc8\x00\x5e\x00\x9d\x00\x6e\x00\x77\x00\x60\x00\x80\x00\x5e\x00\x5e\x00\x5e\x00\x7d\x00\x8b\x00\x8c\x00\x8e\x00\x5d\x00\x15\x00\x16\x00\x18\x00\x32\x00\x19\x00\x31\x00\x1f\x00\x25\x00\x7a\x00\x11\x00\x26\x00\x10\x00\x79\x00\x5e\x00\xc8\x00\xef\x00\xc9\x00\xc8\x00\xc8\x00\xc8\x00\xee\x00\xa5\x00\xa6\x00\xc8\x00\xc8\x00\xaa\x00\xc4\x00\xc8\x00\xc8\x00\xcf\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xcd\x00\xab\x00\xc8\x00\xc8\x00\xc8\x00\xca\x00\xc8\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xa8\x00\xc8\x00\xa9\x00\xc8\x00\xb6\x00\xac\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xae\x00\xc6\x00\xaf\x00\xc8\x00\x5e\x00\xd5\x00\xd5\x00\xff\xff\x60\x00\x76\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x12\x00\xff\xff\xff\xff\x60\x00\x6e\x00\x5e\x00\x5e\x00\x5e\x00\xff\xff\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x5e\x00\xd0\x00\xd0\x00\x78\x00\xff\xff\xff\xff\xff\xff\x64\x00\x20\x00\x5e\x00\x5e\x00\xff\xff\xff\xff\x0f\x00\x60\x00\x7c\x00\x5e\x00\x5e\x00\x5e\x00\x93\x00\x5c\x00\x4a\x00\x0f\x00\xff\xff\xff\xff\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x95\x00\x88\x00\x5e\x00\x5e\x00\x49\x00\x7e\x00\xbe\x00\x60\x00\x7c\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x4f\x00\x62\x00\x0f\x00\x60\x00\x7c\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x63\x00\x65\x00\x70\x00\x60\x00\xa2\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x91\x00\x8b\x00\x7e\x00\xbf\x00\xc0\x00\xc2\x00\x91\x00\xc0\x00\x5e\x00\xc3\x00\xe8\x00\x7e\x00\x0f\x00\xe9\x00\xea\x00\xeb\x00\xed\x00\x5e\x00\x00\x00\x00\x00\x5e\x00\x0f\x00\x00\x00\x00\x00\x60\x00\x0c\x00\x5e\x00\x5e\x00\x5e\x00\x1e\x00\x0f\x00\x00\x00\x00\x00\x27\x00\x0c\x00\xe1\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x5f\x00\x5e\x00\xd0\x00\xd0\x00\x61\x00\xff\xff\x5f\x00\x5f\x00\x5f\x00\x00\x00\x00\x00\x3d\x00\x91\x00\x00\x00\x0f\x00\x00\x00\x7b\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x5f\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x5e\x00\x5e\x00\x5e\x00\x1d\x00\x9e\x00\x5e\x00\x87\x00\x00\x00\x91\x00\x3d\x00\x7b\x00\x5e\x00\x5e\x00\x5e\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x7f\x00\x5e\x00\xe5\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x60\x00\x0c\x00\x5e\x00\x5e\x00\x5e\x00\x5e\x00\x00\x00\x0f\x00\xd5\x00\xd5\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x00\x00\x00\x00\x30\x00\x5e\x00\x00\x00\x00\x00\x1a\x00\x5f\x00\x30\x00\x30\x00\x30\x00\x0c\x00\xff\xff\x5f\x00\x5f\x00\x5f\x00\x0d\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\xbd\x00\xbb\x00\x5f\x00\x4a\x00\x5e\x00\x86\x00\x00\x00\x00\x00\x60\x00\x80\x00\x5e\x00\x5e\x00\x5e\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x5e\x00\x28\x00\x0c\x00\x1c\x00\x00\x00\x2f\x00\x2f\x00\x2f\x00\xa4\x00\xa6\x00\x00\x00\x00\x00\xaa\x00\x0e\x00\x00\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x00\x00\x2f\x00\xab\x00\x5a\x00\x2a\x00\x00\x00\x0c\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xa7\x00\x00\x00\xa9\x00\x29\x00\xbb\x00\xac\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xad\x00\x00\x00\xaf\x00\x81\x00\x81\x00\x81\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x23\x00\x12\x00\x12\x00\x12\x00\x12\x00\x23\x00\x23\x00\x23\x00\x23\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x30\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x59\x00\x00\x00\x23\x00\x8f\x00\x91\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x30\x00\x00\x00\x5b\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x91\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x83\x00\x83\x00\x83\x00\x91\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x13\x00\x13\x00\x13\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x37\x00\x00\x00\x13\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x84\x00\x84\x00\x84\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x17\x00\x17\x00\x17\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x3c\x00\x00\x00\x17\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x00\x2f\x00\x2f\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x23\x00\x23\x00\x23\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x90\x00\x91\x00\x00\x00\x23\x00\x00\x00\x00\x00\x1b\x00\x91\x00\x00\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x2c\x00\x2c\x00\x2c\x00\x4e\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x41\x00\x00\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x91\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x1d\x00\x2c\x00\x53\x00\x91\x00\x00\x00\x00\x00\x3d\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x35\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x35\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x6a\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x3a\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x40\x00\x00\x00\x40\x00\x00\x00\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\x00\x00\x45\x00\x00\x00\x45\x00\x00\x00\x3f\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\x00\x00\x42\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x44\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x47\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x35\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x4c\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x3a\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xb3\x00\xb1\x00\x00\x00\x4d\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\x00\xd1\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\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb2\x00\xb0\x00\x4e\x00\xcb\x00\xb1\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\xcb\x00\x00\x00\xcb\x00\xb0\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\xcb\x00\xe6\x00\xcb\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\xff\xff\x00\x00\x00\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\xd6\x00\x00\x00\x00\x00\x00\x00\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\x53\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\x00\x00\x68\x00\x00\x00\x53\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x53\x00\x68\x00\x9c\x00\x54\x00\x54\x00\x54\x00\xec\x00\x00\x00\x00\x00\x54\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x69\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x69\x00\x9b\x00\x54\x00\x54\x00\x54\x00\xec\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x98\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x97\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x96\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x94\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x5a\x00\x8a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5b\x00\x85\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\xff\xff\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\x6c\x00\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x73\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x6c\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x74\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x89\x00\x6c\x00\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x89\x00\x89\x00\x00\x00\x6f\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x89\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x89\x00\x89\x00\xc8\x00\x6f\x00\x89\x00\x89\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\x71\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\x71\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\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\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x83\x00\x83\x00\x83\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x17\x00\x17\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x84\x00\x84\x00\x84\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x17\x00\x17\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5b\x00\x85\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x82\x00\x82\x00\x82\x00\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x88\x00\x88\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\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\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x5a\x00\x8a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x5a\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x83\x00\x83\x00\x83\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x13\x00\x13\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x83\x00\x84\x00\x84\x00\x84\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\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\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\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\xa0\x00\xa0\x00\xa0\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\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa1\x00\xa1\x00\xa1\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x2c\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x54\x00\x54\x00\x54\x00\x56\x00\x58\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x57\x00\x54\x00\x54\x00\x54\x00\x55\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x54\x00\x00\x00\x92\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb0\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x00\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb1\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb2\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb8\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x45\x00\x00\x00\x45\x00\x00\x00\x00\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbb\x00\xbc\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x00\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbc\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xbd\x00\x00\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xbd\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x72\x00\xc8\x00\xc8\x00\xd4\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x2b\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x9f\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\x8e\x00\xc8\x00\xc8\x00\x99\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x9a\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xa1\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\xa3\x00\xc8\x00\xc8\x00\x00\x00\xc5\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\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\xc8\x00\x00\x00\xc8\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xa1\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa0\x00\xc8\x00\xc8\x00\xc8\x00\xe4\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\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x3d\x00\x00\x00\xc8\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xa0\x00\xcb\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\xa0\x00\x00\x00\xc8\x00\xcb\x00\xc8\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcc\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x00\x00\xcc\x00\xcc\x00\xcc\x00\xcc\x00\xcd\x00\x00\x00\x00\x00\xcc\x00\xcc\x00\x00\x00\xcc\x00\xcc\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcc\x00\xcb\x00\xcc\x00\xcc\x00\xcc\x00\xcc\x00\xcc\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xcd\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\xcb\x00\xcc\x00\xcd\x00\xcc\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xe0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\xce\x00\x00\x00\xcc\x00\x00\x00\xcc\x00\xcd\x00\x00\x00\xcd\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x50\x00\xcd\x00\x00\x00\x4f\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x4c\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x41\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x4d\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\xd2\x00\x4a\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x47\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x48\x00\x00\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\xd7\x00\x00\x00\xec\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x3d\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x3a\x00\x00\x00\x00\x00\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\x00\x00\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\xdc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\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\x00\x00\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--alex_check :: AlexAddr-alex_check = AlexA#-  "\xff\xff\x2d\x00\x01\x00\x02\x00\x2d\x00\x04\x00\x05\x00\x06\x00\x2d\x00\x65\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x65\x00\x7d\x00\x7d\x00\x7d\x00\x61\x00\x2d\x00\x2d\x00\x2d\x00\x69\x00\x6d\x00\x69\x00\x67\x00\x61\x00\x0a\x00\x6e\x00\x72\x00\x6e\x00\x0a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x05\x00\x30\x00\x31\x00\x0a\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x23\x00\x0a\x00\x0a\x00\x09\x00\x2d\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\x30\x00\x31\x00\x23\x00\x0a\x00\x0a\x00\x0a\x00\x2d\x00\x6c\x00\x20\x00\x05\x00\x0a\x00\x0a\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x7c\x00\x21\x00\x5f\x00\x2d\x00\x0a\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x7c\x00\x23\x00\x20\x00\x05\x00\x5f\x00\x23\x00\x23\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x5f\x00\x2d\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x2d\x00\x2d\x00\x2d\x00\x09\x00\x23\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\x24\x00\x7d\x00\x23\x00\x23\x00\x23\x00\x23\x00\x2a\x00\x23\x00\x20\x00\x23\x00\x23\x00\x23\x00\x2d\x00\x23\x00\x23\x00\x23\x00\x23\x00\x20\x00\xff\xff\xff\xff\x05\x00\x2d\x00\xff\xff\xff\xff\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x6c\x00\x2d\x00\xff\xff\xff\xff\x70\x00\x7b\x00\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x05\x00\x20\x00\x30\x00\x31\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x45\x00\x5e\x00\xff\xff\x2d\x00\xff\xff\x7b\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x5f\x00\x7c\x00\x05\x00\x2d\x00\xff\xff\x7c\x00\x65\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x20\x00\x23\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x2d\x00\x30\x00\x31\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\x05\x00\x20\x00\xff\xff\xff\xff\x23\x00\x05\x00\x0b\x00\x0c\x00\x0d\x00\x7b\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x01\x00\x02\x00\x20\x00\x5f\x00\x05\x00\x7b\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x20\x00\x5f\x00\x7b\x00\x23\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x28\x00\x29\x00\xff\xff\xff\xff\x2c\x00\x2d\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x20\x00\x3b\x00\x22\x00\x5f\x00\xff\xff\x7b\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5f\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\x7d\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x05\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\x20\x00\x23\x00\x24\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x20\x00\xff\xff\x22\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x7c\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x20\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x2a\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x02\x00\x03\x00\x5f\x00\xff\xff\xff\xff\x07\x00\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x5e\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\x01\x00\x02\x00\x7c\x00\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\x50\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\x5f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x01\x00\x02\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\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\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\x5f\x00\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x23\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\x0a\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\x5e\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7c\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x23\x00\xff\xff\xff\xff\x07\x00\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\x5e\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7c\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x23\x00\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x04\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x45\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\x7c\x00\x7d\x00\x7e\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x02\x00\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x02\x00\x7c\x00\x04\x00\x7e\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\x45\x00\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x04\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\xff\xff\x5e\x00\xff\xff\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x5f\x00\x7e\x00\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x78\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x42\x00\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x78\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x23\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x45\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--alex_deflt :: AlexAddr-alex_deflt = AlexA#-  "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\xff\xff\x89\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x89\x00\x66\x00\x67\x00\x68\x00\x69\x00\x68\x00\x6b\x00\x6b\x00\x67\x00\x67\x00\x6b\x00\x67\x00\x6b\x00\x67\x00\x66\x00\x66\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x89\x00\x89\x00\x89\x00\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--alex_accept = listArray (0 :: Int, 239)-  [ AlexAccNone-  , AlexAcc 197-  , AlexAccNone-  , AlexAcc 196-  , AlexAcc 195-  , AlexAcc 194-  , AlexAcc 193-  , AlexAcc 192-  , AlexAcc 191-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccNone-  , AlexAccSkip-  , AlexAccSkip-  , AlexAcc 190-  , AlexAcc 189-  , AlexAccPred 188 ( isNormalComment )(AlexAccNone)-  , AlexAccPred 187 ( isNormalComment )(AlexAccNone)-  , AlexAccPred 186 ( isNormalComment )(AlexAccNone)-  , AlexAccPred 185 ( isNormalComment )(AlexAcc 184)-  , AlexAcc 183-  , AlexAcc 182-  , AlexAccPred 181 ( alexNotPred (ifExtension HaddockBit) )(AlexAccNone)-  , AlexAccPred 180 ( alexNotPred (ifExtension HaddockBit) )(AlexAcc 179)-  , AlexAccPred 178 ( alexNotPred (ifExtension HaddockBit) )(AlexAccPred 177 ( ifExtension HaddockBit )(AlexAccNone))-  , AlexAcc 176-  , AlexAccPred 175 ( atEOL )(AlexAccNone)-  , AlexAccPred 174 ( atEOL )(AlexAccNone)-  , AlexAccPred 173 ( atEOL )(AlexAccNone)-  , AlexAccPred 172 ( atEOL )(AlexAcc 171)-  , AlexAccPred 170 ( atEOL )(AlexAcc 169)-  , AlexAccPred 168 ( atEOL )(AlexAccPred 167 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 166 ( followedByOpeningToken )(AlexAccPred 165 ( precededByClosingToken )(AlexAcc 164))))-  , AlexAccPred 163 ( atEOL )(AlexAccPred 162 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 161 ( followedByOpeningToken )(AlexAccPred 160 ( precededByClosingToken )(AlexAcc 159))))-  , AlexAccPred 158 ( atEOL )(AlexAccNone)-  , AlexAccPred 157 ( atEOL )(AlexAccNone)-  , AlexAccPred 156 ( atEOL )(AlexAcc 155)-  , AlexAccSkip-  , AlexAccPred 154 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)-  , AlexAccPred 153 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False) `alexAndPred`  followedByDigit )(AlexAccNone)-  , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)-  , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)-  , AlexAccPred 152 ( notFollowedBy '-' )(AlexAccNone)-  , AlexAccSkip-  , AlexAccPred 151 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)-  , AlexAccPred 150 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)-  , AlexAccPred 149 ( notFollowedBySymbol )(AlexAccNone)-  , AlexAcc 148-  , AlexAccPred 147 ( known_pragma linePrags )(AlexAccNone)-  , AlexAccPred 146 ( known_pragma linePrags )(AlexAcc 145)-  , AlexAccPred 144 ( known_pragma linePrags )(AlexAccPred 143 ( known_pragma oneWordPrags )(AlexAccPred 142 ( known_pragma ignoredPrags )(AlexAccPred 141 ( known_pragma fileHeaderPrags )(AlexAccNone))))-  , AlexAccPred 140 ( known_pragma linePrags )(AlexAccPred 139 ( known_pragma oneWordPrags )(AlexAccPred 138 ( known_pragma ignoredPrags )(AlexAccPred 137 ( known_pragma fileHeaderPrags )(AlexAccNone))))-  , AlexAcc 136-  , AlexAcc 135-  , AlexAcc 134-  , AlexAcc 133-  , AlexAcc 132-  , AlexAcc 131-  , AlexAcc 130-  , AlexAcc 129-  , AlexAccPred 128 ( known_pragma twoWordPrags )(AlexAccNone)-  , AlexAcc 127-  , AlexAcc 126-  , AlexAcc 125-  , AlexAccPred 124 ( ifExtension HaddockBit )(AlexAccNone)-  , AlexAccPred 123 ( ifExtension ThQuotesBit )(AlexAccNone)-  , AlexAccPred 122 ( ifExtension ThQuotesBit )(AlexAccNone)-  , AlexAccPred 121 ( ifExtension ThQuotesBit )(AlexAccPred 120 ( ifExtension QqBit )(AlexAccNone))-  , AlexAccPred 119 ( ifExtension ThQuotesBit )(AlexAccNone)-  , AlexAccPred 118 ( ifExtension ThQuotesBit )(AlexAccPred 117 ( ifExtension QqBit )(AlexAccNone))-  , AlexAccPred 116 ( ifExtension ThQuotesBit )(AlexAccPred 115 ( ifExtension QqBit )(AlexAccNone))-  , AlexAccPred 114 ( ifExtension ThQuotesBit )(AlexAccPred 113 ( ifExtension QqBit )(AlexAccNone))-  , AlexAccPred 112 ( ifExtension ThQuotesBit )(AlexAccNone)-  , AlexAccPred 111 ( ifExtension ThQuotesBit )(AlexAccNone)-  , AlexAccPred 110 ( ifExtension QqBit )(AlexAccNone)-  , AlexAccPred 109 ( ifExtension QqBit )(AlexAccNone)-  , AlexAccPred 108 ( ifCurrentChar '⟦' `alexAndPred`-        ifExtension UnicodeSyntaxBit `alexAndPred`-        ifExtension ThQuotesBit )(AlexAccPred 107 ( ifCurrentChar '⟧' `alexAndPred`-        ifExtension UnicodeSyntaxBit `alexAndPred`-        ifExtension ThQuotesBit )(AlexAccPred 106 ( ifCurrentChar '⦇' `alexAndPred`-        ifExtension UnicodeSyntaxBit `alexAndPred`-        ifExtension ArrowsBit )(AlexAccPred 105 ( ifCurrentChar '⦈' `alexAndPred`-        ifExtension UnicodeSyntaxBit `alexAndPred`-        ifExtension ArrowsBit )(AlexAccNone))))-  , AlexAccPred 104 ( ifExtension ArrowsBit `alexAndPred`-        notFollowedBySymbol )(AlexAccNone)-  , AlexAccPred 103 ( ifExtension ArrowsBit )(AlexAccNone)-  , AlexAccPred 102 ( ifExtension IpBit )(AlexAccNone)-  , AlexAccPred 101 ( ifExtension OverloadedLabelsBit )(AlexAccNone)-  , AlexAccPred 100 ( ifExtension UnboxedTuplesBit `alexOrPred`-           ifExtension UnboxedSumsBit )(AlexAccNone)-  , AlexAccPred 99 ( ifExtension UnboxedTuplesBit `alexOrPred`-           ifExtension UnboxedSumsBit )(AlexAccNone)-  , AlexAcc 98-  , AlexAcc 97-  , AlexAcc 96-  , AlexAcc 95-  , AlexAcc 94-  , AlexAcc 93-  , AlexAcc 92-  , AlexAcc 91-  , AlexAcc 90-  , AlexAcc 89-  , AlexAcc 88-  , AlexAcc 87-  , AlexAcc 86-  , AlexAcc 85-  , AlexAcc 84-  , AlexAcc 83-  , AlexAcc 82-  , AlexAcc 81-  , AlexAcc 80-  , AlexAcc 79-  , AlexAcc 78-  , AlexAcc 77-  , AlexAcc 76-  , AlexAcc 75-  , AlexAcc 74-  , AlexAcc 73-  , AlexAccPred 72 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 71 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 70 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 69 ( ifExtension MagicHashBit )(AlexAccPred 68 ( ifExtension MagicHashBit )(AlexAccNone))-  , AlexAccPred 67 ( ifExtension MagicHashBit )(AlexAccPred 66 ( ifExtension MagicHashBit )(AlexAccNone))-  , AlexAccPred 65 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 64 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 63 ( followedByOpeningToken )(AlexAccPred 62 ( precededByClosingToken )(AlexAcc 61)))-  , AlexAccPred 60 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 59 ( followedByOpeningToken )(AlexAccPred 58 ( precededByClosingToken )(AlexAcc 57)))-  , AlexAccPred 56 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 55 ( followedByOpeningToken )(AlexAccPred 54 ( precededByClosingToken )(AlexAcc 53)))-  , AlexAccPred 52 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 51 ( followedByOpeningToken )(AlexAccPred 50 ( precededByClosingToken )(AlexAcc 49)))-  , AlexAccPred 48 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 47 ( followedByOpeningToken )(AlexAccPred 46 ( precededByClosingToken )(AlexAcc 45)))-  , AlexAccPred 44 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 43 ( followedByOpeningToken )(AlexAccPred 42 ( precededByClosingToken )(AlexAcc 41)))-  , AlexAccPred 40 ( precededByClosingToken `alexAndPred` followedByOpeningToken )(AlexAccPred 39 ( followedByOpeningToken )(AlexAccPred 38 ( precededByClosingToken )(AlexAcc 37)))-  , AlexAcc 36-  , AlexAcc 35-  , AlexAcc 34-  , AlexAcc 33-  , AlexAcc 32-  , AlexAccPred 31 ( ifExtension BinaryLiteralsBit )(AlexAccNone)-  , AlexAcc 30-  , AlexAcc 29-  , AlexAccPred 28 ( ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 27 ( ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 26 ( ifExtension NegativeLiteralsBit `alexAndPred`-                                           ifExtension BinaryLiteralsBit )(AlexAccNone)-  , AlexAccPred 25 ( ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 24 ( ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAcc 23-  , AlexAcc 22-  , AlexAccPred 21 ( ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 20 ( ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 19 ( ifExtension HexFloatLiteralsBit )(AlexAccNone)-  , AlexAccPred 18 ( ifExtension HexFloatLiteralsBit )(AlexAccNone)-  , AlexAccPred 17 ( ifExtension HexFloatLiteralsBit `alexAndPred`-                                           ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 16 ( ifExtension HexFloatLiteralsBit `alexAndPred`-                                           ifExtension NegativeLiteralsBit )(AlexAccNone)-  , AlexAccPred 15 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 14 ( ifExtension MagicHashBit `alexAndPred`-                                           ifExtension BinaryLiteralsBit )(AlexAccNone)-  , AlexAccPred 13 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 12 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 11 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 10 ( ifExtension MagicHashBit `alexAndPred`-                                           ifExtension BinaryLiteralsBit )(AlexAccNone)-  , AlexAccPred 9 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 8 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 7 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 6 ( ifExtension MagicHashBit `alexAndPred`-                                           ifExtension BinaryLiteralsBit )(AlexAccNone)-  , AlexAccPred 5 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 4 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 3 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAccPred 2 ( ifExtension MagicHashBit )(AlexAccNone)-  , AlexAcc 1-  , AlexAcc 0-  ]--alex_actions = array (0 :: Int, 198)-  [ (197,alex_action_14)-  , (196,alex_action_20)-  , (195,alex_action_21)-  , (194,alex_action_19)-  , (193,alex_action_22)-  , (192,alex_action_26)-  , (191,alex_action_27)-  , (190,alex_action_1)-  , (189,alex_action_1)-  , (188,alex_action_2)-  , (187,alex_action_2)-  , (186,alex_action_2)-  , (185,alex_action_2)-  , (184,alex_action_27)-  , (183,alex_action_3)-  , (182,alex_action_4)-  , (181,alex_action_5)-  , (180,alex_action_5)-  , (179,alex_action_27)-  , (178,alex_action_5)-  , (177,alex_action_38)-  , (176,alex_action_6)-  , (175,alex_action_7)-  , (174,alex_action_7)-  , (173,alex_action_7)-  , (172,alex_action_7)-  , (171,alex_action_27)-  , (170,alex_action_7)-  , (169,alex_action_27)-  , (168,alex_action_7)-  , (167,alex_action_78)-  , (166,alex_action_79)-  , (165,alex_action_80)-  , (164,alex_action_81)-  , (163,alex_action_7)-  , (162,alex_action_78)-  , (161,alex_action_79)-  , (160,alex_action_80)-  , (159,alex_action_81)-  , (158,alex_action_8)-  , (157,alex_action_8)-  , (156,alex_action_8)-  , (155,alex_action_27)-  , (154,alex_action_10)-  , (153,alex_action_11)-  , (152,alex_action_15)-  , (151,alex_action_17)-  , (150,alex_action_17)-  , (149,alex_action_18)-  , (148,alex_action_23)-  , (147,alex_action_24)-  , (146,alex_action_24)-  , (145,alex_action_27)-  , (144,alex_action_24)-  , (143,alex_action_32)-  , (142,alex_action_33)-  , (141,alex_action_35)-  , (140,alex_action_24)-  , (139,alex_action_32)-  , (138,alex_action_33)-  , (137,alex_action_36)-  , (136,alex_action_25)-  , (135,alex_action_27)-  , (134,alex_action_27)-  , (133,alex_action_27)-  , (132,alex_action_27)-  , (131,alex_action_28)-  , (130,alex_action_29)-  , (129,alex_action_30)-  , (128,alex_action_31)-  , (127,alex_action_34)-  , (126,alex_action_37)-  , (125,alex_action_37)-  , (124,alex_action_39)-  , (123,alex_action_40)-  , (122,alex_action_41)-  , (121,alex_action_42)-  , (120,alex_action_49)-  , (119,alex_action_43)-  , (118,alex_action_44)-  , (117,alex_action_49)-  , (116,alex_action_45)-  , (115,alex_action_49)-  , (114,alex_action_46)-  , (113,alex_action_49)-  , (112,alex_action_47)-  , (111,alex_action_48)-  , (110,alex_action_49)-  , (109,alex_action_50)-  , (108,alex_action_51)-  , (107,alex_action_52)-  , (106,alex_action_55)-  , (105,alex_action_56)-  , (104,alex_action_53)-  , (103,alex_action_54)-  , (102,alex_action_57)-  , (101,alex_action_58)-  , (100,alex_action_59)-  , (99,alex_action_60)-  , (98,alex_action_61)-  , (97,alex_action_61)-  , (96,alex_action_62)-  , (95,alex_action_63)-  , (94,alex_action_63)-  , (93,alex_action_64)-  , (92,alex_action_65)-  , (91,alex_action_66)-  , (90,alex_action_67)-  , (89,alex_action_68)-  , (88,alex_action_68)-  , (87,alex_action_69)-  , (86,alex_action_70)-  , (85,alex_action_70)-  , (84,alex_action_71)-  , (83,alex_action_71)-  , (82,alex_action_72)-  , (81,alex_action_72)-  , (80,alex_action_72)-  , (79,alex_action_72)-  , (78,alex_action_72)-  , (77,alex_action_72)-  , (76,alex_action_72)-  , (75,alex_action_72)-  , (74,alex_action_73)-  , (73,alex_action_73)-  , (72,alex_action_74)-  , (71,alex_action_75)-  , (70,alex_action_76)-  , (69,alex_action_76)-  , (68,alex_action_109)-  , (67,alex_action_76)-  , (66,alex_action_110)-  , (65,alex_action_77)-  , (64,alex_action_78)-  , (63,alex_action_79)-  , (62,alex_action_80)-  , (61,alex_action_81)-  , (60,alex_action_78)-  , (59,alex_action_79)-  , (58,alex_action_80)-  , (57,alex_action_81)-  , (56,alex_action_78)-  , (55,alex_action_79)-  , (54,alex_action_80)-  , (53,alex_action_81)-  , (52,alex_action_78)-  , (51,alex_action_79)-  , (50,alex_action_80)-  , (49,alex_action_81)-  , (48,alex_action_78)-  , (47,alex_action_79)-  , (46,alex_action_80)-  , (45,alex_action_81)-  , (44,alex_action_78)-  , (43,alex_action_79)-  , (42,alex_action_80)-  , (41,alex_action_81)-  , (40,alex_action_78)-  , (39,alex_action_79)-  , (38,alex_action_80)-  , (37,alex_action_81)-  , (36,alex_action_82)-  , (35,alex_action_83)-  , (34,alex_action_84)-  , (33,alex_action_85)-  , (32,alex_action_85)-  , (31,alex_action_86)-  , (30,alex_action_87)-  , (29,alex_action_88)-  , (28,alex_action_89)-  , (27,alex_action_89)-  , (26,alex_action_90)-  , (25,alex_action_91)-  , (24,alex_action_92)-  , (23,alex_action_93)-  , (22,alex_action_93)-  , (21,alex_action_94)-  , (20,alex_action_94)-  , (19,alex_action_95)-  , (18,alex_action_95)-  , (17,alex_action_96)-  , (16,alex_action_96)-  , (15,alex_action_97)-  , (14,alex_action_98)-  , (13,alex_action_99)-  , (12,alex_action_100)-  , (11,alex_action_101)-  , (10,alex_action_102)-  , (9,alex_action_103)-  , (8,alex_action_104)-  , (7,alex_action_105)-  , (6,alex_action_106)-  , (5,alex_action_107)-  , (4,alex_action_108)-  , (3,alex_action_109)-  , (2,alex_action_110)-  , (1,alex_action_111)-  , (0,alex_action_112)-  ]--{-# LINE 661 "compiler/parser/Lexer.x" #-}----- -------------------------------------------------------------------------------- The token type--data Token-  = ITas                        -- Haskell keywords-  | ITcase-  | ITclass-  | ITdata-  | ITdefault-  | ITderiving-  | ITdo-  | ITelse-  | IThiding-  | ITforeign-  | ITif-  | ITimport-  | ITin-  | ITinfix-  | ITinfixl-  | ITinfixr-  | ITinstance-  | ITlet-  | ITmodule-  | ITnewtype-  | ITof-  | ITqualified-  | ITthen-  | ITtype-  | ITwhere--  | ITforall            IsUnicodeSyntax -- GHC extension keywords-  | ITexport-  | ITlabel-  | ITdynamic-  | ITsafe-  | ITinterruptible-  | ITunsafe-  | ITstdcallconv-  | ITccallconv-  | ITcapiconv-  | ITprimcallconv-  | ITjavascriptcallconv-  | ITmdo-  | ITfamily-  | ITrole-  | ITgroup-  | ITby-  | ITusing-  | ITpattern-  | ITstatic-  | ITstock-  | ITanyclass-  | ITvia--  -- Backpack tokens-  | ITunit-  | ITsignature-  | ITdependency-  | ITrequires--  -- Pragmas, see  note [Pragma source text] in BasicTypes-  | ITinline_prag       SourceText InlineSpec RuleMatchInfo-  | ITspec_prag         SourceText                -- SPECIALISE-  | ITspec_inline_prag  SourceText Bool    -- SPECIALISE INLINE (or NOINLINE)-  | ITsource_prag       SourceText-  | ITrules_prag        SourceText-  | ITwarning_prag      SourceText-  | ITdeprecated_prag   SourceText-  | ITline_prag         SourceText  -- not usually produced, see 'UsePosPragsBit'-  | ITcolumn_prag       SourceText  -- not usually produced, see 'UsePosPragsBit'-  | ITscc_prag          SourceText-  | ITgenerated_prag    SourceText-  | ITcore_prag         SourceText         -- hdaume: core annotations-  | ITunpack_prag       SourceText-  | ITnounpack_prag     SourceText-  | ITann_prag          SourceText-  | ITcomplete_prag     SourceText-  | ITclose_prag-  | IToptions_prag String-  | ITinclude_prag String-  | ITlanguage_prag-  | ITminimal_prag      SourceText-  | IToverlappable_prag SourceText  -- instance overlap mode-  | IToverlapping_prag  SourceText  -- instance overlap mode-  | IToverlaps_prag     SourceText  -- instance overlap mode-  | ITincoherent_prag   SourceText  -- instance overlap mode-  | ITctype             SourceText-  | ITcomment_line_prag         -- See Note [Nested comment line pragmas]--  | ITdotdot                    -- reserved symbols-  | ITcolon-  | ITdcolon            IsUnicodeSyntax-  | ITequal-  | ITlam-  | ITlcase-  | ITvbar-  | ITlarrow            IsUnicodeSyntax-  | ITrarrow            IsUnicodeSyntax-  | ITdarrow            IsUnicodeSyntax-  | ITminus-  | ITbang     -- Prefix (!) only, e.g. f !x = rhs-  | ITtilde    -- Prefix (~) only, e.g. f ~x = rhs-  | ITat       -- Tight infix (@) only, e.g. f x@pat = rhs-  | ITtypeApp  -- Prefix (@) only, e.g. f @t-  | ITstar              IsUnicodeSyntax-  | ITdot--  | ITbiglam                    -- GHC-extension symbols--  | ITocurly                    -- special symbols-  | ITccurly-  | ITvocurly-  | ITvccurly-  | ITobrack-  | ITopabrack                  -- [:, for parallel arrays with -XParallelArrays-  | ITcpabrack                  -- :], for parallel arrays with -XParallelArrays-  | ITcbrack-  | IToparen-  | ITcparen-  | IToubxparen-  | ITcubxparen-  | ITsemi-  | ITcomma-  | ITunderscore-  | ITbackquote-  | ITsimpleQuote               --  '--  | ITvarid   FastString        -- identifiers-  | ITconid   FastString-  | ITvarsym  FastString-  | ITconsym  FastString-  | ITqvarid  (FastString,FastString)-  | ITqconid  (FastString,FastString)-  | ITqvarsym (FastString,FastString)-  | ITqconsym (FastString,FastString)--  | ITdupipvarid   FastString   -- GHC extension: implicit param: ?x-  | ITlabelvarid   FastString   -- Overloaded label: #x--  | ITchar     SourceText Char       -- Note [Literal source text] in BasicTypes-  | ITstring   SourceText FastString -- Note [Literal source text] in BasicTypes-  | ITinteger  IntegralLit           -- Note [Literal source text] in BasicTypes-  | ITrational FractionalLit--  | ITprimchar   SourceText Char     -- Note [Literal source text] in BasicTypes-  | ITprimstring SourceText ByteString -- Note [Literal source text] @BasicTypes-  | ITprimint    SourceText Integer  -- Note [Literal source text] in BasicTypes-  | ITprimword   SourceText Integer  -- Note [Literal source text] in BasicTypes-  | ITprimfloat  FractionalLit-  | ITprimdouble FractionalLit--  -- Template Haskell extension tokens-  | ITopenExpQuote HasE IsUnicodeSyntax --  [| or [e|-  | ITopenPatQuote                      --  [p|-  | ITopenDecQuote                      --  [d|-  | ITopenTypQuote                      --  [t|-  | ITcloseQuote IsUnicodeSyntax        --  |]-  | ITopenTExpQuote HasE                --  [|| or [e||-  | ITcloseTExpQuote                    --  ||]-  | ITdollar                            --  prefix $-  | ITdollardollar                      --  prefix $$-  | ITtyQuote                           --  ''-  | ITquasiQuote (FastString,FastString,PsSpan)-    -- ITquasiQuote(quoter, quote, loc)-    -- represents a quasi-quote of the form-    -- [quoter| quote |]-  | ITqQuasiQuote (FastString,FastString,FastString,PsSpan)-    -- ITqQuasiQuote(Qual, quoter, quote, loc)-    -- represents a qualified quasi-quote of the form-    -- [Qual.quoter| quote |]--  -- Arrow notation extension-  | ITproc-  | ITrec-  | IToparenbar  IsUnicodeSyntax -- ^ @(|@-  | ITcparenbar  IsUnicodeSyntax -- ^ @|)@-  | ITlarrowtail IsUnicodeSyntax -- ^ @-<@-  | ITrarrowtail IsUnicodeSyntax -- ^ @>-@-  | ITLarrowtail IsUnicodeSyntax -- ^ @-<<@-  | ITRarrowtail IsUnicodeSyntax -- ^ @>>-@--  | ITunknown String             -- ^ Used when the lexer can't make sense of it-  | ITeof                        -- ^ end of file token--  -- Documentation annotations-  | ITdocCommentNext  String     -- ^ something beginning @-- |@-  | ITdocCommentPrev  String     -- ^ something beginning @-- ^@-  | ITdocCommentNamed String     -- ^ something beginning @-- $@-  | ITdocSection      Int String -- ^ a section heading-  | ITdocOptions      String     -- ^ doc options (prune, ignore-exports, etc)-  | ITlineComment     String     -- ^ comment starting by "--"-  | ITblockComment    String     -- ^ comment in {- -}--  deriving Show--instance Outputable Token where-  ppr x = text (show x)----- the bitmap provided as the third component indicates whether the--- corresponding extension keyword is valid under the extension options--- provided to the compiler; if the extension corresponding to *any* of the--- bits set in the bitmap is enabled, the keyword is valid (this setup--- facilitates using a keyword in two different extensions that can be--- activated independently)----reservedWordsFM :: UniqFM (Token, ExtsBitmap)-reservedWordsFM = listToUFM $-    map (\(x, y, z) -> (mkFastString x, (y, z)))-        [( "_",              ITunderscore,    0 ),-         ( "as",             ITas,            0 ),-         ( "case",           ITcase,          0 ),-         ( "class",          ITclass,         0 ),-         ( "data",           ITdata,          0 ),-         ( "default",        ITdefault,       0 ),-         ( "deriving",       ITderiving,      0 ),-         ( "do",             ITdo,            0 ),-         ( "else",           ITelse,          0 ),-         ( "hiding",         IThiding,        0 ),-         ( "if",             ITif,            0 ),-         ( "import",         ITimport,        0 ),-         ( "in",             ITin,            0 ),-         ( "infix",          ITinfix,         0 ),-         ( "infixl",         ITinfixl,        0 ),-         ( "infixr",         ITinfixr,        0 ),-         ( "instance",       ITinstance,      0 ),-         ( "let",            ITlet,           0 ),-         ( "module",         ITmodule,        0 ),-         ( "newtype",        ITnewtype,       0 ),-         ( "of",             ITof,            0 ),-         ( "qualified",      ITqualified,     0 ),-         ( "then",           ITthen,          0 ),-         ( "type",           ITtype,          0 ),-         ( "where",          ITwhere,         0 ),--         ( "forall",         ITforall NormalSyntax, 0),-         ( "mdo",            ITmdo,           xbit RecursiveDoBit),-             -- See Note [Lexing type pseudo-keywords]-         ( "family",         ITfamily,        0 ),-         ( "role",           ITrole,          0 ),-         ( "pattern",        ITpattern,       xbit PatternSynonymsBit),-         ( "static",         ITstatic,        xbit StaticPointersBit ),-         ( "stock",          ITstock,         0 ),-         ( "anyclass",       ITanyclass,      0 ),-         ( "via",            ITvia,           0 ),-         ( "group",          ITgroup,         xbit TransformComprehensionsBit),-         ( "by",             ITby,            xbit TransformComprehensionsBit),-         ( "using",          ITusing,         xbit TransformComprehensionsBit),--         ( "foreign",        ITforeign,       xbit FfiBit),-         ( "export",         ITexport,        xbit FfiBit),-         ( "label",          ITlabel,         xbit FfiBit),-         ( "dynamic",        ITdynamic,       xbit FfiBit),-         ( "safe",           ITsafe,          xbit FfiBit .|.-                                              xbit SafeHaskellBit),-         ( "interruptible",  ITinterruptible, xbit InterruptibleFfiBit),-         ( "unsafe",         ITunsafe,        xbit FfiBit),-         ( "stdcall",        ITstdcallconv,   xbit FfiBit),-         ( "ccall",          ITccallconv,     xbit FfiBit),-         ( "capi",           ITcapiconv,      xbit CApiFfiBit),-         ( "prim",           ITprimcallconv,  xbit FfiBit),-         ( "javascript",     ITjavascriptcallconv, xbit FfiBit),--         ( "unit",           ITunit,          0 ),-         ( "dependency",     ITdependency,       0 ),-         ( "signature",      ITsignature,     0 ),--         ( "rec",            ITrec,           xbit ArrowsBit .|.-                                              xbit RecursiveDoBit),-         ( "proc",           ITproc,          xbit ArrowsBit)-     ]--{------------------------------------Note [Lexing type pseudo-keywords]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--One might think that we wish to treat 'family' and 'role' as regular old-varids whenever -XTypeFamilies and -XRoleAnnotations are off, respectively.-But, there is no need to do so. These pseudo-keywords are not stolen syntax:-they are only used after the keyword 'type' at the top-level, where varids are-not allowed. Furthermore, checks further downstream (TcTyClsDecls) ensure that-type families and role annotations are never declared without their extensions-on. In fact, by unconditionally lexing these pseudo-keywords as special, we-can get better error messages.--Also, note that these are included in the `varid` production in the parser ---a key detail to make all this work.--------------------------------------}--reservedSymsFM :: UniqFM (Token, IsUnicodeSyntax, ExtsBitmap)-reservedSymsFM = listToUFM $-    map (\ (x,w,y,z) -> (mkFastString x,(w,y,z)))-      [ ("..",  ITdotdot,                   NormalSyntax,  0 )-        -- (:) is a reserved op, meaning only list cons-       ,(":",   ITcolon,                    NormalSyntax,  0 )-       ,("::",  ITdcolon NormalSyntax,      NormalSyntax,  0 )-       ,("=",   ITequal,                    NormalSyntax,  0 )-       ,("\\",  ITlam,                      NormalSyntax,  0 )-       ,("|",   ITvbar,                     NormalSyntax,  0 )-       ,("<-",  ITlarrow NormalSyntax,      NormalSyntax,  0 )-       ,("->",  ITrarrow NormalSyntax,      NormalSyntax,  0 )-       ,("=>",  ITdarrow NormalSyntax,      NormalSyntax,  0 )-       ,("-",   ITminus,                    NormalSyntax,  0 )--       ,("*",   ITstar NormalSyntax,        NormalSyntax,  xbit StarIsTypeBit)--        -- For 'forall a . t'-       ,(".",   ITdot,                      NormalSyntax,  0 )--       ,("-<",  ITlarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)-       ,(">-",  ITrarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)-       ,("-<<", ITLarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)-       ,(">>-", ITRarrowtail NormalSyntax,  NormalSyntax,  xbit ArrowsBit)--       ,("∷",   ITdcolon UnicodeSyntax,     UnicodeSyntax, 0 )-       ,("⇒",   ITdarrow UnicodeSyntax,     UnicodeSyntax, 0 )-       ,("∀",   ITforall UnicodeSyntax,     UnicodeSyntax, 0 )-       ,("→",   ITrarrow UnicodeSyntax,     UnicodeSyntax, 0 )-       ,("←",   ITlarrow UnicodeSyntax,     UnicodeSyntax, 0 )--       ,("⤙",   ITlarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)-       ,("⤚",   ITrarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)-       ,("⤛",   ITLarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)-       ,("⤜",   ITRarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)--       ,("★",   ITstar UnicodeSyntax,       UnicodeSyntax, xbit StarIsTypeBit)--        -- ToDo: ideally, → and ∷ should be "specials", so that they cannot-        -- form part of a large operator.  This would let us have a better-        -- syntax for kinds: ɑ∷*→* would be a legal kind signature. (maybe).-       ]---- -------------------------------------------------------------------------------- Lexer actions--type Action = PsSpan -> StringBuffer -> Int -> P (PsLocated Token)--special :: Token -> Action-special tok span _buf _len = return (L span tok)--token, layout_token :: Token -> Action-token t span _buf _len = return (L span t)-layout_token t span _buf _len = pushLexState layout >> return (L span t)--idtoken :: (StringBuffer -> Int -> Token) -> Action-idtoken f span buf len = return (L span $! (f buf len))--skip_one_varid :: (FastString -> Token) -> Action-skip_one_varid f span buf len-  = return (L span $! f (lexemeToFastString (stepOn buf) (len-1)))--skip_two_varid :: (FastString -> Token) -> Action-skip_two_varid f span buf len-  = return (L span $! f (lexemeToFastString (stepOn (stepOn buf)) (len-2)))--strtoken :: (String -> Token) -> Action-strtoken f span buf len =-  return (L span $! (f $! lexemeToString buf len))--begin :: Int -> Action-begin code _span _str _len = do pushLexState code; lexToken--pop :: Action-pop _span _buf _len = do _ <- popLexState-                         lexToken--- See Note [Nested comment line pragmas]-failLinePrag1 :: Action-failLinePrag1 span _buf _len = do-  b <- getBit InNestedCommentBit-  if b then return (L span ITcomment_line_prag)-       else lexError "lexical error in pragma"---- See Note [Nested comment line pragmas]-popLinePrag1 :: Action-popLinePrag1 span _buf _len = do-  b <- getBit InNestedCommentBit-  if b then return (L span ITcomment_line_prag) else do-    _ <- popLexState-    lexToken--hopefully_open_brace :: Action-hopefully_open_brace span buf len- = do relaxed <- getBit RelaxedLayoutBit-      ctx <- getContext-      (AI l _) <- getInput-      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 (mkSrcSpanPs span) (text "Missing block")--pop_and :: Action -> Action-pop_and act span buf len = do _ <- popLexState-                              act span buf len---- See Note [Whitespace-sensitive operator parsing]-followedByOpeningToken :: AlexAccPred ExtsBitmap-followedByOpeningToken _ _ _ (AI _ buf)-  | atEnd buf = False-  | otherwise =-      case nextChar buf of-        ('{', buf') -> nextCharIsNot buf' (== '-')-        ('(', _) -> True-        ('[', _) -> True-        ('\"', _) -> True-        ('\'', _) -> True-        ('_', _) -> True-        (c, _) -> isAlphaNum c---- See Note [Whitespace-sensitive operator parsing]-precededByClosingToken :: AlexAccPred ExtsBitmap-precededByClosingToken _ (AI _ buf) _ _ =-  case prevChar buf '\n' of-    '}' -> decodePrevNChars 1 buf /= "-"-    ')' -> True-    ']' -> True-    '\"' -> True-    '\'' -> True-    '_' -> True-    c -> isAlphaNum c--{-# INLINE nextCharIs #-}-nextCharIs :: StringBuffer -> (Char -> Bool) -> Bool-nextCharIs buf p = not (atEnd buf) && p (currentChar buf)--{-# INLINE nextCharIsNot #-}-nextCharIsNot :: StringBuffer -> (Char -> Bool) -> Bool-nextCharIsNot buf p = not (nextCharIs buf p)--notFollowedBy :: Char -> AlexAccPred ExtsBitmap-notFollowedBy char _ _ _ (AI _ buf)-  = nextCharIsNot buf (== char)--notFollowedBySymbol :: AlexAccPred ExtsBitmap-notFollowedBySymbol _ _ _ (AI _ buf)-  = nextCharIsNot buf (`elem` "!#$%&*+./<=>?@\\^|-~")--followedByDigit :: AlexAccPred ExtsBitmap-followedByDigit _ _ _ (AI _ buf)-  = afterOptionalSpace buf (\b -> nextCharIs b (`elem` ['0'..'9']))--ifCurrentChar :: Char -> AlexAccPred ExtsBitmap-ifCurrentChar char _ (AI _ buf) _ _-  = nextCharIs buf (== char)---- We must reject doc comments as being ordinary comments everywhere.--- In some cases the doc comment will be selected as the lexeme due to--- maximal munch, but not always, because the nested comment rule is--- valid in all states, but the doc-comment rules are only valid in--- the non-layout states.-isNormalComment :: AlexAccPred ExtsBitmap-isNormalComment bits _ _ (AI _ buf)-  | HaddockBit `xtest` bits = notFollowedByDocOrPragma-  | otherwise               = nextCharIsNot buf (== '#')-  where-    notFollowedByDocOrPragma-       = afterOptionalSpace buf (\b -> nextCharIsNot b (`elem` "|^*$#"))--afterOptionalSpace :: StringBuffer -> (StringBuffer -> Bool) -> Bool-afterOptionalSpace buf p-    = if nextCharIs buf (== ' ')-      then p (snd (nextChar buf))-      else p buf--atEOL :: AlexAccPred ExtsBitmap-atEOL _ _ _ (AI _ buf) = atEnd buf || currentChar buf == '\n'--ifExtension :: ExtBits -> AlexAccPred ExtsBitmap-ifExtension extBits bits _ _ _ = extBits `xtest` bits--alexNotPred p userState in1 len in2-  = not (p userState in1 len in2)--alexOrPred p1 p2 userState in1 len in2-  = p1 userState in1 len in2 || p2 userState in1 len in2--multiline_doc_comment :: Action-multiline_doc_comment span buf _len = withLexedDocType (worker "")-  where-    worker commentAcc input docType checkNextLine = case alexGetChar' input of-      Just ('\n', input')-        | checkNextLine -> case checkIfCommentLine input' of-          Just input -> worker ('\n':commentAcc) input docType checkNextLine-          Nothing -> docCommentEnd input commentAcc docType buf span-        | otherwise -> docCommentEnd input commentAcc docType buf span-      Just (c, input) -> worker (c:commentAcc) input docType checkNextLine-      Nothing -> docCommentEnd input commentAcc docType buf span--    -- Check if the next line of input belongs to this doc comment as well.-    -- A doc comment continues onto the next line when the following-    -- conditions are met:-    --   * The line starts with "--"-    --   * The line doesn't start with "---".-    --   * The line doesn't start with "-- $", because that would be the-    --     start of a /new/ named haddock chunk (#10398).-    checkIfCommentLine :: AlexInput -> Maybe AlexInput-    checkIfCommentLine input = check (dropNonNewlineSpace input)-      where-        check input = do-          ('-', input) <- alexGetChar' input-          ('-', input) <- alexGetChar' input-          (c, after_c) <- alexGetChar' input-          case c of-            '-' -> Nothing-            ' ' -> case alexGetChar' after_c of-                     Just ('$', _) -> Nothing-                     _ -> Just input-            _   -> Just input--        dropNonNewlineSpace input = case alexGetChar' input of-          Just (c, input')-            | isSpace c && c /= '\n' -> dropNonNewlineSpace input'-            | otherwise -> input-          Nothing -> input--lineCommentToken :: Action-lineCommentToken span buf len = do-  b <- getBit RawTokenStreamBit-  if b then strtoken ITlineComment span buf len else lexToken--{--  nested comments require traversing by hand, they can't be parsed-  using regular expressions.--}-nested_comment :: P (PsLocated Token) -> Action-nested_comment cont span buf len = do-  input <- getInput-  go (reverse $ lexemeToString buf len) (1::Int) input-  where-    go commentAcc 0 input = do-      setInput input-      b <- getBit RawTokenStreamBit-      if b-        then docCommentEnd input commentAcc ITblockComment buf span-        else cont-    go commentAcc n input = case alexGetChar' input of-      Nothing -> errBrace input (psRealSpan span)-      Just ('-',input) -> case alexGetChar' input of-        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 (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 (psRealSpan span)-        Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input-                           go (parsedAcc ++ '\n':commentAcc) n input-        Just (_,_)   -> go ('\n':commentAcc) n input-      Just (c,input) -> go (c:commentAcc) n input--nested_doc_comment :: Action-nested_doc_comment span buf _len = withLexedDocType (go "")-  where-    go commentAcc input docType _ = case alexGetChar' input of-      Nothing -> errBrace input (psRealSpan span)-      Just ('-',input) -> case alexGetChar' input of-        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 (psRealSpan span)-        Just ('-',input) -> do-          setInput input-          let cont = do input <- getInput; go commentAcc input docType False-          nested_comment cont span buf _len-        Just (_,_) -> go ('\123':commentAcc) input docType False-      -- See Note [Nested comment line pragmas]-      Just ('\n',input) -> case alexGetChar' input of-        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-      Just (c,input) -> go (c:commentAcc) input docType False---- See Note [Nested comment line pragmas]-parseNestedPragma :: AlexInput -> P (String,AlexInput)-parseNestedPragma input@(AI _ buf) = do-  origInput <- getInput-  setInput input-  setExts (.|. xbit InNestedCommentBit)-  pushLexState bol-  lt <- lexToken-  _ <- popLexState-  setExts (.&. complement (xbit InNestedCommentBit))-  postInput@(AI _ postBuf) <- getInput-  setInput origInput-  case unLoc lt of-    ITcomment_line_prag -> do-      let bytes = byteDiff buf postBuf-          diff  = lexemeToString buf bytes-      return (reverse diff, postInput)-    lt' -> panic ("parseNestedPragma: unexpected token" ++ (show lt'))--{--Note [Nested comment line pragmas]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We used to ignore cpp-preprocessor-generated #line pragmas if they were inside-nested comments.--Now, when parsing a nested comment, if we encounter a line starting with '#' we-call parseNestedPragma, which executes the following:-1. Save the current lexer input (loc, buf) for later-2. Set the current lexer input to the beginning of the line starting with '#'-3. Turn the 'InNestedComment' extension on-4. Push the 'bol' lexer state-5. Lex a token. Due to (2), (3), and (4), this should always lex a single line-   or less and return the ITcomment_line_prag token. This may set source line-   and file location if a #line pragma is successfully parsed-6. Restore lexer input and state to what they were before we did all this-7. Return control to the function parsing a nested comment, informing it of-   what the lexer parsed--Regarding (5) above:-Every exit from the 'bol' lexer state (do_bol, popLinePrag1, failLinePrag1)-checks if the 'InNestedComment' extension is set. If it is, that function will-return control to parseNestedPragma by returning the ITcomment_line_prag token.--See #314 for more background on the bug this fixes.--}--withLexedDocType :: (AlexInput -> (String -> Token) -> Bool -> P (PsLocated Token))-                 -> P (PsLocated Token)-withLexedDocType lexDocComment = do-  input@(AI _ buf) <- getInput-  case prevChar buf ' ' of-    -- The `Bool` argument to lexDocComment signals whether or not the next-    -- line of input might also belong to this doc comment.-    '|' -> lexDocComment input ITdocCommentNext True-    '^' -> lexDocComment input ITdocCommentPrev True-    '$' -> lexDocComment input ITdocCommentNamed True-    '*' -> lexDocSection 1 input-    _ -> panic "withLexedDocType: Bad doc type"- where-    lexDocSection n input = case alexGetChar' input of-      Just ('*', input) -> lexDocSection (n+1) input-      Just (_,   _)     -> lexDocComment input (ITdocSection n) False-      Nothing -> do setInput input; lexToken -- eof reached, lex it normally---- RULES pragmas turn on the forall and '.' keywords, and we turn them--- off again at the end of the pragma.-rulePrag :: Action-rulePrag span buf len = do-  setExts (.|. xbit InRulePragBit)-  let !src = lexemeToString buf len-  return (L span (ITrules_prag (SourceText src)))---- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead--- of updating the position in 'PState'-linePrag :: Action-linePrag span buf len = do-  usePosPrags <- getBit UsePosPragsBit-  if usePosPrags-    then begin line_prag2 span buf len-    else let !src = lexemeToString buf len-         in return (L span (ITline_prag (SourceText src)))---- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead--- of updating the position in 'PState'-columnPrag :: Action-columnPrag span buf len = do-  usePosPrags <- getBit UsePosPragsBit-  let !src = lexemeToString buf len-  if usePosPrags-    then begin column_prag span buf len-    else let !src = lexemeToString buf len-         in return (L span (ITcolumn_prag (SourceText src)))--endPrag :: Action-endPrag span _buf _len = do-  setExts (.&. complement (xbit InRulePragBit))-  return (L span ITclose_prag)---- docCommentEnd----------------------------------------------------------------------------------- This function is quite tricky. We can't just return a new token, we also--- need to update the state of the parser. Why? Because the token is longer--- than what was lexed by Alex, and the lexToken function doesn't know this, so--- it writes the wrong token length to the parser state. This function is--- called afterwards, so it can just update the state.--docCommentEnd :: AlexInput -> String -> (String -> Token) -> StringBuffer ->-                 PsSpan -> P (PsLocated Token)-docCommentEnd input commentAcc docType buf span = do-  setInput input-  let (AI loc nextBuf) = input-      comment = reverse commentAcc-      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) (psRealLoc end) "unterminated `{-'"--open_brace, close_brace :: Action-open_brace span _str _len = do-  ctx <- getContext-  setContext (NoLayout:ctx)-  return (L span ITocurly)-close_brace span _str _len = do-  popContext-  return (L span ITccurly)--qvarid, qconid :: StringBuffer -> Int -> Token-qvarid buf len = ITqvarid $! splitQualName buf len False-qconid buf len = ITqconid $! splitQualName buf len False--splitQualName :: StringBuffer -> Int -> Bool -> (FastString,FastString)--- takes a StringBuffer and a length, and returns the module name--- and identifier parts of a qualified name.  Splits at the *last* dot,--- because of hierarchical module names.-splitQualName orig_buf len parens = split orig_buf orig_buf-  where-    split buf dot_buf-        | orig_buf `byteDiff` buf >= len  = done dot_buf-        | c == '.'                        = found_dot buf'-        | otherwise                       = split buf' dot_buf-      where-       (c,buf') = nextChar buf--    -- careful, we might get names like M....-    -- so, if the character after the dot is not upper-case, this is-    -- the end of the qualifier part.-    found_dot buf -- buf points after the '.'-        | isUpper c    = split buf' buf-        | otherwise    = done buf-      where-       (c,buf') = nextChar buf--    done dot_buf =-        (lexemeToFastString orig_buf (qual_size - 1),-         if parens -- Prelude.(+)-            then lexemeToFastString (stepOn dot_buf) (len - qual_size - 2)-            else lexemeToFastString dot_buf (len - qual_size))-      where-        qual_size = orig_buf `byteDiff` dot_buf--varid :: Action-varid span buf len =-  case lookupUFM reservedWordsFM fs of-    Just (ITcase, _) -> do-      lastTk <- getLastTk-      keyword <- case lastTk of-        Just ITlam -> do-          lambdaCase <- getBit LambdaCaseBit-          unless lambdaCase $ do-            pState <- getPState-            addError (mkSrcSpanPs (last_loc pState)) $ text-                     "Illegal lambda-case (use LambdaCase)"-          return ITlcase-        _ -> return ITcase-      maybe_layout keyword-      return $ L span keyword-    Just (keyword, 0) -> do-      maybe_layout keyword-      return $ L span keyword-    Just (keyword, i) -> do-      exts <- getExts-      if exts .&. i /= 0-        then do-          maybe_layout keyword-          return $ L span keyword-        else-          return $ L span $ ITvarid fs-    Nothing ->-      return $ L span $ ITvarid fs-  where-    !fs = lexemeToFastString buf len--conid :: StringBuffer -> Int -> Token-conid buf len = ITconid $! lexemeToFastString buf len--qvarsym, qconsym :: StringBuffer -> Int -> Token-qvarsym buf len = ITqvarsym $! splitQualName buf len False-qconsym buf len = ITqconsym $! splitQualName buf len False---- See Note [Whitespace-sensitive operator parsing]-varsym_prefix :: Action-varsym_prefix = sym $ \exts s ->-  if | TypeApplicationsBit `xtest` exts, s == fsLit "@"-     -> return ITtypeApp-     | ThQuotesBit `xtest` exts, s == fsLit "$"-     -> return ITdollar-     | ThQuotesBit `xtest` exts, s == fsLit "$$"-     -> return ITdollardollar-     | s == fsLit "!" -> return ITbang-     | s == fsLit "~" -> return ITtilde-     | otherwise -> return (ITvarsym s)---- See Note [Whitespace-sensitive operator parsing]-varsym_suffix :: Action-varsym_suffix = sym $ \_ s ->-  if | s == fsLit "@"-     -> failMsgP "Suffix occurrence of @. For an as-pattern, remove the leading whitespace."-     | otherwise -> return (ITvarsym s)---- See Note [Whitespace-sensitive operator parsing]-varsym_tight_infix :: Action-varsym_tight_infix = sym $ \_ s ->-  if | s == fsLit "@" -> return ITat-     | otherwise -> return (ITvarsym s)---- See Note [Whitespace-sensitive operator parsing]-varsym_loose_infix :: Action-varsym_loose_infix = sym (\_ s -> return $ ITvarsym s)--consym :: Action-consym = sym (\_exts s -> return $ ITconsym s)--sym :: (ExtsBitmap -> FastString -> P Token) -> Action-sym con span buf len =-  case lookupUFM reservedSymsFM fs of-    Just (keyword, NormalSyntax, 0) ->-      return $ L span keyword-    Just (keyword, NormalSyntax, i) -> do-      exts <- getExts-      if exts .&. i /= 0-        then return $ L span keyword-        else L span <$!> con exts fs-    Just (keyword, UnicodeSyntax, 0) -> do-      exts <- getExts-      if xtest UnicodeSyntaxBit exts-        then return $ L span keyword-        else L span <$!> con exts fs-    Just (keyword, UnicodeSyntax, i) -> do-      exts <- getExts-      if exts .&. i /= 0 && xtest UnicodeSyntaxBit exts-        then return $ L span keyword-        else L span <$!> con exts fs-    Nothing -> do-      exts <- getExts-      L span <$!> con exts fs-  where-    !fs = lexemeToFastString buf len---- Variations on the integral numeric literal.-tok_integral :: (SourceText -> Integer -> Token)-             -> (Integer -> Integer)-             -> Int -> Int-             -> (Integer, (Char -> Int))-             -> Action-tok_integral itint transint transbuf translen (radix,char_to_int) span buf len = do-  numericUnderscores <- getBit NumericUnderscoresBit  -- #14473-  let src = lexemeToString buf len-  when ((not numericUnderscores) && ('_' `elem` src)) $ do-    pState <- getPState-    addError (mkSrcSpanPs (last_loc pState)) $ text-             "Use NumericUnderscores to allow underscores in integer literals"-  return $ L span $ itint (SourceText src)-       $! transint $ parseUnsignedInteger-       (offsetBytes transbuf buf) (subtract translen len) radix char_to_int--tok_num :: (Integer -> Integer)-        -> Int -> Int-        -> (Integer, (Char->Int)) -> Action-tok_num = tok_integral $ \case-    st@(SourceText ('-':_)) -> itint st (const True)-    st@(SourceText _)       -> itint st (const False)-    st@NoSourceText         -> itint st (< 0)-  where-    itint :: SourceText -> (Integer -> Bool) -> Integer -> Token-    itint !st is_negative !val = ITinteger ((IL st $! is_negative val) val)--tok_primint :: (Integer -> Integer)-            -> Int -> Int-            -> (Integer, (Char->Int)) -> Action-tok_primint = tok_integral ITprimint---tok_primword :: Int -> Int-             -> (Integer, (Char->Int)) -> Action-tok_primword = tok_integral ITprimword positive-positive, negative :: (Integer -> Integer)-positive = id-negative = negate-decimal, octal, hexadecimal :: (Integer, Char -> Int)-decimal = (10,octDecDigit)-binary = (2,octDecDigit)-octal = (8,octDecDigit)-hexadecimal = (16,hexDigit)---- readRational can understand negative rationals, exponents, everything.-tok_frac :: Int -> (String -> Token) -> Action-tok_frac drop f span buf len = do-  numericUnderscores <- getBit NumericUnderscoresBit  -- #14473-  let src = lexemeToString buf (len-drop)-  when ((not numericUnderscores) && ('_' `elem` src)) $ do-    pState <- getPState-    addError (mkSrcSpanPs (last_loc pState)) $ text-             "Use NumericUnderscores to allow underscores in floating literals"-  return (L span $! (f $! src))--tok_float, tok_primfloat, tok_primdouble :: String -> Token-tok_float        str = ITrational   $! readFractionalLit str-tok_hex_float    str = ITrational   $! readHexFractionalLit str-tok_primfloat    str = ITprimfloat  $! readFractionalLit str-tok_primdouble   str = ITprimdouble $! readFractionalLit str--readFractionalLit :: String -> FractionalLit-readFractionalLit str = ((FL $! (SourceText str)) $! is_neg) $! readRational str-                        where is_neg = case str of ('-':_) -> True-                                                   _       -> False-readHexFractionalLit :: String -> FractionalLit-readHexFractionalLit str =-  FL { fl_text  = SourceText str-     , fl_neg   = case str of-                    '-' : _ -> True-                    _       -> False-     , fl_value = readHexRational str-     }---- -------------------------------------------------------------------------------- Layout processing---- we're at the first token on a line, insert layout tokens if necessary-do_bol :: Action-do_bol span _str _len = do-        -- See Note [Nested comment line pragmas]-        b <- getBit InNestedCommentBit-        if b then return (L span ITcomment_line_prag) else do-          (pos, gen_semic) <- getOffside-          case pos of-              LT -> do-                  --trace "layout: inserting '}'" $ do-                  popContext-                  -- do NOT pop the lex state, we might have a ';' to insert-                  return (L span ITvccurly)-              EQ | gen_semic -> do-                  --trace "layout: inserting ';'" $ do-                  _ <- popLexState-                  return (L span ITsemi)-              _ -> do-                  _ <- popLexState-                  lexToken---- certain keywords put us in the "layout" state, where we might--- add an opening curly brace.-maybe_layout :: Token -> P ()-maybe_layout t = do -- If the alternative layout rule is enabled then-                    -- we never create an implicit layout context here.-                    -- Layout is handled XXX instead.-                    -- The code for closing implicit contexts, or-                    -- inserting implicit semi-colons, is therefore-                    -- irrelevant as it only applies in an implicit-                    -- context.-                    alr <- getBit AlternativeLayoutRuleBit-                    unless alr $ f t-    where f ITdo    = pushLexState layout_do-          f ITmdo   = pushLexState layout_do-          f ITof    = pushLexState layout-          f ITlcase = pushLexState layout-          f ITlet   = pushLexState layout-          f ITwhere = pushLexState layout-          f ITrec   = pushLexState layout-          f ITif    = pushLexState layout_if-          f _       = return ()---- Pushing a new implicit layout context.  If the indentation of the--- next token is not greater than the previous layout context, then--- Haskell 98 says that the new layout context should be empty; that is--- the lexer must generate {}.------ We are slightly more lenient than this: when the new context is started--- by a 'do', then we allow the new context to be at the same indentation as--- the previous context.  This is what the 'strict' argument is for.-new_layout_context :: Bool -> Bool -> Token -> Action-new_layout_context strict gen_semic tok span _buf len = do-    _ <- popLexState-    (AI l _) <- getInput-    let offset = srcLocCol (psRealLoc l) - len-    ctx <- getContext-    nondecreasing <- getBit NondecreasingIndentationBit-    let strict' = strict || not nondecreasing-    case ctx of-        Layout prev_off _ : _  |-           (strict'     && prev_off >= offset  ||-            not strict' && prev_off > offset) -> do-                -- token is indented to the left of the previous context.-                -- we must generate a {} sequence now.-                pushLexState layout_left-                return (L span tok)-        _ -> do setContext (Layout offset gen_semic : ctx)-                return (L span tok)--do_layout_left :: Action-do_layout_left span _buf _len = do-    _ <- popLexState-    pushLexState bol  -- we must be at the start of a line-    return (L span ITvccurly)---- -------------------------------------------------------------------------------- LINE pragmas--setLineAndFile :: Int -> Action-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-      file = mkFastString $ go $ drop 1 $ dropWhile (/= '"') src-          -- skip everything through first quotation mark to get to the filename-        where go ('\\':c:cs) = c : go cs-              go (c:cs)      = c : go cs-              go []          = []-              -- decode escapes in the filename.  e.g. on Windows-              -- when our filenames have backslashes in, gcc seems to-              -- escape the backslashes.  One symptom of not doing this-              -- is that filenames in error messages look a bit strange:-              --   C:\\foo\bar.hs-              -- only the first backslash is doubled, because we apply-              -- System.FilePath.normalise before printing out-              -- filenames and it does not remove duplicate-              -- backslashes after the drive letter (should it?).-  resetAlrLastLoc file-  setSrcLoc (mkRealSrcLoc file (fromIntegral linenum - 1) (srcSpanEndCol span))-      -- subtract one: the line number refers to the *following* line-  addSrcFile file-  _ <- popLexState-  pushLexState code-  lexToken--setColumn :: Action-setColumn (PsSpan span _) buf len = do-  let column =-        case reads (lexemeToString buf len) of-          [(column, _)] -> column-          _ -> error "setColumn: expected integer" -- shouldn't happen-  setSrcLoc (mkRealSrcLoc (srcSpanFile span) (srcSpanEndLine span)-                          (fromIntegral (column :: Integer)))-  _ <- popLexState-  lexToken--alrInitialLoc :: FastString -> RealSrcSpan-alrInitialLoc file = mkRealSrcSpan loc loc-    where -- This is a hack to ensure that the first line in a file-          -- looks like it is after the initial location:-          loc = mkRealSrcLoc file (-1) (-1)---- -------------------------------------------------------------------------------- Options, includes and language pragmas.--lex_string_prag :: (String -> Token) -> Action-lex_string_prag mkTok span _buf _len-    = do input <- getInput-         start <- getParsedLoc-         tok <- go [] input-         end <- getParsedLoc-         return (L (mkPsSpan start end) tok)-    where go acc input-              = if isString input "#-}"-                   then do setInput input-                           return (mkTok (reverse acc))-                   else case alexGetChar input of-                          Just (c,i) -> go (c:acc) i-                          Nothing -> err input-          isString _ [] = True-          isString i (x:xs)-              = case alexGetChar i of-                  Just (c,i') | c == x    -> isString i' xs-                  _other -> False-          err (AI end _) = failLocMsgP (realSrcSpanStart (psRealSpan span)) (psRealLoc end) "unterminated options pragma"----- -------------------------------------------------------------------------------- Strings & Chars---- This stuff is horrible.  I hates it.--lex_string_tok :: Action-lex_string_tok span buf _len = do-  tok <- lex_string ""-  (AI end bufEnd) <- getInput-  let-    tok' = case tok of-            ITprimstring _ bs -> ITprimstring (SourceText src) bs-            ITstring _ s -> ITstring (SourceText src) s-            _ -> panic "lex_string_tok"-    src = lexemeToString buf (cur bufEnd - cur buf)-  return (L (mkPsSpan (psSpanStart span) end) tok')--lex_string :: String -> P Token-lex_string s = do-  i <- getInput-  case alexGetChar' i of-    Nothing -> lit_error i--    Just ('"',i)  -> do-        setInput i-        let s' = reverse s-        magicHash <- getBit MagicHashBit-        if magicHash-          then do-            i <- getInput-            case alexGetChar' i of-              Just ('#',i) -> do-                setInput i-                when (any (> '\xFF') s') $ do-                  pState <- getPState-                  addError (mkSrcSpanPs (last_loc pState)) $ text-                     "primitive string literal must contain only characters <= \'\\xFF\'"-                return (ITprimstring (SourceText s') (unsafeMkByteString s'))-              _other ->-                return (ITstring (SourceText s') (mkFastString s'))-          else-                return (ITstring (SourceText s') (mkFastString s'))--    Just ('\\',i)-        | Just ('&',i) <- next -> do-                setInput i; lex_string s-        | Just (c,i) <- next, c <= '\x7f' && is_space c -> do-                           -- is_space only works for <= '\x7f' (#3751, #5425)-                setInput i; lex_stringgap s-        where next = alexGetChar' i--    Just (c, i1) -> do-        case c of-          '\\' -> do setInput i1; c' <- lex_escape; lex_string (c':s)-          c | isAny c -> do setInput i1; lex_string (c:s)-          _other -> lit_error i--lex_stringgap :: String -> P Token-lex_stringgap s = do-  i <- getInput-  c <- getCharOrFail i-  case c of-    '\\' -> lex_string s-    c | c <= '\x7f' && is_space c -> lex_stringgap s-                           -- is_space only works for <= '\x7f' (#3751, #5425)-    _other -> lit_error i---lex_char_tok :: Action--- Here we are basically parsing character literals, such as 'x' or '\n'--- but we additionally spot 'x and ''T, returning ITsimpleQuote and--- ITtyQuote respectively, but WITHOUT CONSUMING the x or T part--- (the parser does that).--- So we have to do two characters of lookahead: when we see 'x we need to--- 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 = psSpanStart span-   case alexGetChar' i1 of-        Nothing -> lit_error  i1--        Just ('\'', i2@(AI end2 _)) -> do       -- We've seen ''-                   setInput i2-                   return (L (mkPsSpan loc end2)  ITtyQuote)--        Just ('\\', i2@(AI _end2 _)) -> do      -- We've seen 'backslash-                  setInput i2-                  lit_ch <- lex_escape-                  i3 <- getInput-                  mc <- getCharOrFail i3 -- Trailing quote-                  if mc == '\'' then finish_char_tok buf loc lit_ch-                                else lit_error i3--        Just (c, i2@(AI _end2 _))-                | not (isAny c) -> lit_error i1-                | otherwise ->--                -- We've seen 'x, where x is a valid character-                --  (i.e. not newline etc) but not a quote or backslash-           case alexGetChar' i2 of      -- Look ahead one more character-                Just ('\'', i3) -> do   -- We've seen 'x'-                        setInput i3-                        finish_char_tok buf loc c-                _other -> do            -- We've seen 'x not followed by quote-                                        -- (including the possibility of EOF)-                                        -- Just parse the quote only-                        let (AI end _) = i1-                        return (L (mkPsSpan loc end) ITsimpleQuote)--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-        i@(AI end bufEnd) <- getInput-        let src = lexemeToString buf (cur bufEnd - cur buf)-        if magicHash then do-            case alexGetChar' i of-              Just ('#',i@(AI end _)) -> do-                setInput i-                return (L (mkPsSpan loc end)-                          (ITprimchar (SourceText src) ch))-              _other ->-                return (L (mkPsSpan loc end)-                          (ITchar (SourceText src) ch))-            else do-              return (L (mkPsSpan loc end) (ITchar (SourceText src) ch))--isAny :: Char -> Bool-isAny c | c > '\x7f' = isPrint c-        | otherwise  = is_any c--lex_escape :: P Char-lex_escape = do-  i0 <- getInput-  c <- getCharOrFail i0-  case c of-        'a'   -> return '\a'-        'b'   -> return '\b'-        'f'   -> return '\f'-        'n'   -> return '\n'-        'r'   -> return '\r'-        't'   -> return '\t'-        'v'   -> return '\v'-        '\\'  -> return '\\'-        '"'   -> return '\"'-        '\''  -> return '\''-        '^'   -> do i1 <- getInput-                    c <- getCharOrFail i1-                    if c >= '@' && c <= '_'-                        then return (chr (ord c - ord '@'))-                        else lit_error i1--        'x'   -> readNum is_hexdigit 16 hexDigit-        'o'   -> readNum is_octdigit  8 octDecDigit-        x | is_decdigit x -> readNum2 is_decdigit 10 octDecDigit (octDecDigit x)--        c1 ->  do-           i <- getInput-           case alexGetChar' i of-            Nothing -> lit_error i0-            Just (c2,i2) ->-              case alexGetChar' i2 of-                Nothing -> do lit_error i0-                Just (c3,i3) ->-                   let str = [c1,c2,c3] in-                   case [ (c,rest) | (p,c) <- silly_escape_chars,-                                     Just rest <- [stripPrefix p str] ] of-                          (escape_char,[]):_ -> do-                                setInput i3-                                return escape_char-                          (escape_char,_:_):_ -> do-                                setInput i2-                                return escape_char-                          [] -> lit_error i0--readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Char-readNum is_digit base conv = do-  i <- getInput-  c <- getCharOrFail i-  if is_digit c-        then readNum2 is_digit base conv (conv c)-        else lit_error i--readNum2 :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> P Char-readNum2 is_digit base conv i = do-  input <- getInput-  read i input-  where read i input = do-          case alexGetChar' input of-            Just (c,input') | is_digit c -> do-               let i' = i*base + conv c-               if i' > 0x10ffff-                  then setInput input >> lexError "numeric escape sequence out of range"-                  else read i' input'-            _other -> do-              setInput input; return (chr i)---silly_escape_chars :: [(String, Char)]-silly_escape_chars = [-        ("NUL", '\NUL'),-        ("SOH", '\SOH'),-        ("STX", '\STX'),-        ("ETX", '\ETX'),-        ("EOT", '\EOT'),-        ("ENQ", '\ENQ'),-        ("ACK", '\ACK'),-        ("BEL", '\BEL'),-        ("BS", '\BS'),-        ("HT", '\HT'),-        ("LF", '\LF'),-        ("VT", '\VT'),-        ("FF", '\FF'),-        ("CR", '\CR'),-        ("SO", '\SO'),-        ("SI", '\SI'),-        ("DLE", '\DLE'),-        ("DC1", '\DC1'),-        ("DC2", '\DC2'),-        ("DC3", '\DC3'),-        ("DC4", '\DC4'),-        ("NAK", '\NAK'),-        ("SYN", '\SYN'),-        ("ETB", '\ETB'),-        ("CAN", '\CAN'),-        ("EM", '\EM'),-        ("SUB", '\SUB'),-        ("ESC", '\ESC'),-        ("FS", '\FS'),-        ("GS", '\GS'),-        ("RS", '\RS'),-        ("US", '\US'),-        ("SP", '\SP'),-        ("DEL", '\DEL')-        ]---- before calling lit_error, ensure that the current input is pointing to--- the position of the error in the buffer.  This is so that we can report--- a correct location to the user, but also so we can detect UTF-8 decoding--- errors if they occur.-lit_error :: AlexInput -> P a-lit_error i = do setInput i; lexError "lexical error in string/character literal"--getCharOrFail :: AlexInput -> P Char-getCharOrFail i =  do-  case alexGetChar' i of-        Nothing -> lexError "unexpected end-of-file in string/character literal"-        Just (c,i)  -> do setInput i; return c---- -------------------------------------------------------------------------------- QuasiQuote--lex_qquasiquote_tok :: Action-lex_qquasiquote_tok span buf len = do-  let (qual, quoter) = splitQualName (stepOn buf) (len - 2) False-  quoteStart <- getParsedLoc-  quote <- lex_quasiquote (psRealLoc quoteStart) ""-  end <- getParsedLoc-  return (L (mkPsSpan (psSpanStart span) end)-           (ITqQuasiQuote (qual,-                           quoter,-                           mkFastString (reverse quote),-                           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 <- getParsedLoc-  quote <- lex_quasiquote (psRealLoc quoteStart) ""-  end <- getParsedLoc-  return (L (mkPsSpan (psSpanStart span) end)-           (ITquasiQuote (mkFastString quoter,-                          mkFastString (reverse quote),-                          mkPsSpan quoteStart end)))--lex_quasiquote :: RealSrcLoc -> String -> P String-lex_quasiquote start s = do-  i <- getInput-  case alexGetChar' i of-    Nothing -> quasiquote_error start--    -- NB: The string "|]" terminates the quasiquote,-    -- with absolutely no escaping. See the extensive-    -- discussion on #5348 for why there is no-    -- escape handling.-    Just ('|',i)-        | Just (']',i) <- alexGetChar' i-        -> do { setInput i; return s }--    Just (c, i) -> do-         setInput i; lex_quasiquote start (c : s)--quasiquote_error :: RealSrcLoc -> P a-quasiquote_error start = do-  (AI end buf) <- getInput-  reportLexError start (psRealLoc end) buf "unterminated quasiquotation"---- -------------------------------------------------------------------------------- Warnings--warnTab :: Action-warnTab srcspan _buf _len = do-    addTabWarning (psRealSpan srcspan)-    lexToken--warnThen :: WarningFlag -> SDoc -> Action -> Action-warnThen option warning action srcspan buf len = do-    addWarning option (RealSrcSpan (psRealSpan srcspan) Nothing) warning-    action srcspan buf len---- -------------------------------------------------------------------------------- The Parse Monad---- | Do we want to generate ';' layout tokens? In some cases we just want to--- generate '}', e.g. in MultiWayIf we don't need ';'s because '|' separates--- alternatives (unlike a `case` expression where we need ';' to as a separator--- between alternatives).-type GenSemic = Bool--generateSemic, dontGenerateSemic :: GenSemic-generateSemic     = True-dontGenerateSemic = False--data LayoutContext-  = NoLayout-  | Layout !Int !GenSemic-  deriving Show---- | The result of running a parser.-data ParseResult a-  = POk      -- ^ The parser has consumed a (possibly empty) prefix-             --   of the input and produced a result. Use 'getMessages'-             --   to check for accumulated warnings and non-fatal errors.-      PState -- ^ The resulting parsing state. Can be used to resume parsing.-      a      -- ^ The resulting value.-  | PFailed  -- ^ The parser has consumed a (possibly empty) prefix-             --   of the input and failed.-      PState -- ^ The parsing state right before failure, including the fatal-             --   parse error. 'getMessages' and 'getErrorMessages' must return-             --   a non-empty bag of errors.---- | Test whether a 'WarningFlag' is set-warnopt :: WarningFlag -> ParserFlags -> Bool-warnopt f options = f `EnumSet.member` pWarningFlags options---- | The subset of the 'DynFlags' used by the parser.--- See 'mkParserFlags' or 'mkParserFlags'' for ways to construct this.-data ParserFlags = ParserFlags {-    pWarningFlags   :: EnumSet WarningFlag-  , pThisPackage    :: UnitId      -- ^ key of package currently being compiled-  , pExtsBitmap     :: !ExtsBitmap -- ^ bitmap of permitted extensions-  }--data PState = PState {-        buffer     :: StringBuffer,-        options    :: ParserFlags,-        -- This needs to take DynFlags as an argument until-        -- we have a fix for #10143-        messages   :: DynFlags -> Messages,-        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   :: PsSpan,      -- pos of previous token-        last_len   :: !Int,        -- len of previous token-        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 :: [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 (PsLocated Token),-        -- This is what we consider to be the location of the last token-        -- emitted:-        alr_last_loc :: PsSpan,-        -- The stack of layout contexts:-        alr_context :: [ALRContext],-        -- Are we expecting a '{'? If it's Just, then the ALRLayout tells-        -- us what sort of layout the '{' will open:-        alr_expecting_ocurly :: Maybe ALRLayout,-        -- Have we just had the '}' for a let block? If so, than an 'in'-        -- token doesn't need to close anything:-        alr_justClosedExplicitLetBlock :: Bool,--        -- The next three are used to implement Annotations giving the-        -- locations of 'noise' tokens in the source, so that users of-        -- the GHC API can do source to source conversions.-        -- See note [Api annotations] in ApiAnnotation.hs-        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-        -- current token to happyError, we could at least get rid of last_len.-        -- Getting rid of last_loc would require finding another way to-        -- implement pushCurrentContext (which is only called from one place).--data ALRContext = ALRNoLayout Bool{- does it contain commas? -}-                              Bool{- is it a 'let' block? -}-                | ALRLayout ALRLayout Int-data ALRLayout = ALRLayoutLet-               | ALRLayoutWhere-               | ALRLayoutOf-               | ALRLayoutDo---- | The parsing monad, isomorphic to @StateT PState Maybe@.-newtype P a = P { unP :: PState -> ParseResult a }--instance Functor P where-  fmap = liftM--instance Applicative P where-  pure = returnP-  (<*>) = ap--instance Monad P where-  (>>=) = thenP--returnP :: a -> P a-returnP a = a `seq` (P $ \s -> POk s a)--thenP :: P a -> (a -> P b) -> P b-(P m) `thenP` k = P $ \ s ->-        case m s of-                POk s1 a         -> (unP (k a)) s1-                PFailed s1 -> PFailed s1--failMsgP :: String -> P a-failMsgP msg = do-  pState <- getPState-  addFatalError (mkSrcSpanPs (last_loc pState)) (text msg)--failLocMsgP :: RealSrcLoc -> RealSrcLoc -> String -> P a-failLocMsgP loc1 loc2 str =-  addFatalError (RealSrcSpan (mkRealSrcSpan loc1 loc2) Nothing) (text str)--getPState :: P PState-getPState = P $ \s -> POk s s--withThisPackage :: (UnitId -> a) -> P a-withThisPackage f = P $ \s@(PState{options = o}) -> POk s (f (pThisPackage o))--getExts :: P ExtsBitmap-getExts = P $ \s -> POk s (pExtsBitmap . options $ s)--setExts :: (ExtsBitmap -> ExtsBitmap) -> P ()-setExts f = P $ \s -> POk s {-  options =-    let p = options s-    in  p { pExtsBitmap = f (pExtsBitmap p) }-  } ()--setSrcLoc :: RealSrcLoc -> P ()-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 (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 } ()--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-  } ()--setLastTk :: Token -> P ()-setLastTk tk = P $ \s -> POk s { last_tk = Just tk } ()--getLastTk :: P (Maybe Token)-getLastTk = P $ \s@(PState { last_tk = last_tk }) -> POk s last_tk--data AlexInput = AI PsLoc StringBuffer--{--Note [Unicode in Alex]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Although newer versions of Alex support unicode, this grammar is processed with-the old style '--latin1' behaviour. This means that when implementing the-functions--    alexGetByte       :: AlexInput -> Maybe (Word8,AlexInput)-    alexInputPrevChar :: AlexInput -> Char--which Alex uses to take apart our 'AlexInput', we must--  * return a latin1 character in the 'Word8' that 'alexGetByte' expects-  * return a latin1 character in 'alexInputPrevChar'.--We handle this in 'adjustChar' by squishing entire classes of unicode-characters into single bytes.--}--{-# INLINE adjustChar #-}-adjustChar :: Char -> Word8-adjustChar c = fromIntegral $ ord adj_c-  where non_graphic     = '\x00'-        upper           = '\x01'-        lower           = '\x02'-        digit           = '\x03'-        symbol          = '\x04'-        space           = '\x05'-        other_graphic   = '\x06'-        uniidchar       = '\x07'--        adj_c-          | c <= '\x07' = non_graphic-          | c <= '\x7f' = c-          -- Alex doesn't handle Unicode, so when Unicode-          -- character is encountered we output these values-          -- with the actual character value hidden in the state.-          | otherwise =-                -- NB: The logic behind these definitions is also reflected-                -- in basicTypes/Lexeme.hs-                -- Any changes here should likely be reflected there.--                case generalCategory c of-                  UppercaseLetter       -> upper-                  LowercaseLetter       -> lower-                  TitlecaseLetter       -> upper-                  ModifierLetter        -> uniidchar -- see #10196-                  OtherLetter           -> lower -- see #1103-                  NonSpacingMark        -> uniidchar -- see #7650-                  SpacingCombiningMark  -> other_graphic-                  EnclosingMark         -> other_graphic-                  DecimalNumber         -> digit-                  LetterNumber          -> other_graphic-                  OtherNumber           -> digit -- see #4373-                  ConnectorPunctuation  -> symbol-                  DashPunctuation       -> symbol-                  OpenPunctuation       -> other_graphic-                  ClosePunctuation      -> other_graphic-                  InitialQuote          -> other_graphic-                  FinalQuote            -> other_graphic-                  OtherPunctuation      -> symbol-                  MathSymbol            -> symbol-                  CurrencySymbol        -> symbol-                  ModifierSymbol        -> symbol-                  OtherSymbol           -> symbol-                  Space                 -> space-                  _other                -> non_graphic---- Getting the previous 'Char' isn't enough here - we need to convert it into--- the same format that 'alexGetByte' would have produced.------ See Note [Unicode in Alex] and #13986.-alexInputPrevChar :: AlexInput -> Char-alexInputPrevChar (AI _ buf) = chr (fromIntegral (adjustChar pc))-  where pc = prevChar buf '\n'---- backwards compatibility for Alex 2.x-alexGetChar :: AlexInput -> Maybe (Char,AlexInput)-alexGetChar inp = case alexGetByte inp of-                    Nothing    -> Nothing-                    Just (b,i) -> c `seq` Just (c,i)-                       where c = chr $ fromIntegral b---- See Note [Unicode in Alex]-alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)-alexGetByte (AI loc s)-  | atEnd s   = Nothing-  | otherwise = byte `seq` loc' `seq` s' `seq`-                --trace (show (ord c)) $-                Just (byte, (AI loc' s'))-  where (c,s') = nextChar s-        loc'   = advancePsLoc loc c-        byte   = adjustChar c---- This version does not squash unicode characters, it is used when--- lexing strings.-alexGetChar' :: AlexInput -> Maybe (Char,AlexInput)-alexGetChar' (AI loc s)-  | atEnd s   = Nothing-  | otherwise = c `seq` loc' `seq` s' `seq`-                --trace (show (ord c)) $-                Just (c, (AI loc' s'))-  where (c,s') = nextChar s-        loc'   = advancePsLoc loc c--getInput :: P AlexInput-getInput = P $ \s@PState{ loc=l, buffer=b } -> POk s (AI l b)--setInput :: AlexInput -> P ()-setInput (AI l b) = P $ \s -> POk s{ loc=l, buffer=b } ()--nextIsEOF :: P Bool-nextIsEOF = do-  AI _ s <- getInput-  return $ atEnd s--pushLexState :: Int -> P ()-pushLexState ls = P $ \s@PState{ lex_state=l } -> POk s{lex_state=ls:l} ()--popLexState :: P Int-popLexState = P $ \s@PState{ lex_state=ls:l } -> POk s{ lex_state=l } ls--getLexState :: P Int-getLexState = P $ \s@PState{ lex_state=ls:_ } -> POk s ls--popNextToken :: P (Maybe (PsLocated Token))-popNextToken-    = P $ \s@PState{ alr_next_token = m } ->-              POk (s {alr_next_token = Nothing}) m--activeContext :: P Bool-activeContext = do-  ctxt <- getALRContext-  expc <- getAlrExpectingOCurly-  impt <- implicitTokenPending-  case (ctxt,expc) of-    ([],Nothing) -> return impt-    _other       -> return True--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 PsSpan-getAlrLastLoc = P $ \s@(PState {alr_last_loc = l}) -> POk s l--getALRContext :: P [ALRContext]-getALRContext = P $ \s@(PState {alr_context = cs}) -> POk s cs--setALRContext :: [ALRContext] -> P ()-setALRContext cs = P $ \s -> POk (s {alr_context = cs}) ()--getJustClosedExplicitLetBlock :: P Bool-getJustClosedExplicitLetBlock- = P $ \s@(PState {alr_justClosedExplicitLetBlock = b}) -> POk s b--setJustClosedExplicitLetBlock :: Bool -> P ()-setJustClosedExplicitLetBlock b- = P $ \s -> POk (s {alr_justClosedExplicitLetBlock = b}) ()--setNextToken :: PsLocated Token -> P ()-setNextToken t = P $ \s -> POk (s {alr_next_token = Just t}) ()--implicitTokenPending :: P Bool-implicitTokenPending-    = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->-              case ts of-              [] -> POk s False-              _  -> POk s True--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 :: [PsLocated Token] -> P ()-setPendingImplicitTokens ts = P $ \s -> POk (s {alr_pending_implicit_tokens = ts}) ()--getAlrExpectingOCurly :: P (Maybe ALRLayout)-getAlrExpectingOCurly = P $ \s@(PState {alr_expecting_ocurly = b}) -> POk s b--setAlrExpectingOCurly :: Maybe ALRLayout -> P ()-setAlrExpectingOCurly b = P $ \s -> POk (s {alr_expecting_ocurly = b}) ()---- | For reasons of efficiency, boolean parsing flags (eg, language extensions--- or whether we are currently in a @RULE@ pragma) are represented by a bitmap--- stored in a @Word64@.-type ExtsBitmap = Word64--xbit :: ExtBits -> ExtsBitmap-xbit = bit . fromEnum--xtest :: ExtBits -> ExtsBitmap -> Bool-xtest ext xmap = testBit xmap (fromEnum ext)---- | Various boolean flags, mostly language extensions, that impact lexing and--- parsing. Note that a handful of these can change during lexing/parsing.-data ExtBits-  -- Flags that are constant once parsing starts-  = FfiBit-  | InterruptibleFfiBit-  | CApiFfiBit-  | ArrowsBit-  | ThBit-  | ThQuotesBit-  | IpBit-  | OverloadedLabelsBit -- #x overloaded labels-  | ExplicitForallBit -- the 'forall' keyword-  | BangPatBit -- Tells the parser to understand bang-patterns-               -- (doesn't affect the lexer)-  | PatternSynonymsBit -- pattern synonyms-  | HaddockBit-- Lex and parse Haddock comments-  | MagicHashBit -- "#" in both functions and operators-  | RecursiveDoBit -- mdo-  | UnicodeSyntaxBit -- the forall symbol, arrow symbols, etc-  | UnboxedTuplesBit -- (# and #)-  | UnboxedSumsBit -- (# and #)-  | DatatypeContextsBit-  | MonadComprehensionsBit-  | TransformComprehensionsBit-  | QqBit -- enable quasiquoting-  | RawTokenStreamBit -- producing a token stream with all comments included-  | AlternativeLayoutRuleBit-  | ALRTransitionalBit-  | RelaxedLayoutBit-  | NondecreasingIndentationBit-  | SafeHaskellBit-  | TraditionalRecordSyntaxBit-  | ExplicitNamespacesBit-  | LambdaCaseBit-  | BinaryLiteralsBit-  | NegativeLiteralsBit-  | HexFloatLiteralsBit-  | TypeApplicationsBit-  | StaticPointersBit-  | NumericUnderscoresBit-  | StarIsTypeBit-  | BlockArgumentsBit-  | NPlusKPatternsBit-  | DoAndIfThenElseBit-  | MultiWayIfBit-  | GadtSyntaxBit-  | ImportQualifiedPostBit--  -- Flags that are updated once parsing starts-  | InRulePragBit-  | InNestedCommentBit -- See Note [Nested comment line pragmas]-  | UsePosPragsBit-    -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}'-    -- update the internal position. Otherwise, those pragmas are lexed as-    -- tokens of their own.-  deriving Enum-------- PState for parsing options pragmas----pragState :: DynFlags -> StringBuffer -> RealSrcLoc -> PState-pragState dynflags buf loc = (mkPState dynflags buf loc) {-                                 lex_state = [bol, option_prags, 0]-                             }--{-# INLINE mkParserFlags' #-}-mkParserFlags'-  :: EnumSet WarningFlag        -- ^ warnings flags enabled-  -> EnumSet LangExt.Extension  -- ^ permitted language extensions enabled-  -> UnitId                     -- ^ key of package currently being compiled-  -> Bool                       -- ^ are safe imports on?-  -> Bool                       -- ^ keeping Haddock comment tokens-  -> Bool                       -- ^ keep regular comment tokens--  -> Bool-  -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update-  -- the internal position kept by the parser. Otherwise, those pragmas are-  -- lexed as 'ITline_prag' and 'ITcolumn_prag' tokens.--  -> ParserFlags--- ^ Given exactly the information needed, set up the 'ParserFlags'-mkParserFlags' warningFlags extensionFlags thisPackage-  safeImports isHaddock rawTokStream usePosPrags =-    ParserFlags {-      pWarningFlags = warningFlags-    , pThisPackage = thisPackage-    , pExtsBitmap = safeHaskellBit .|. langExtBits .|. optBits-    }-  where-    safeHaskellBit = SafeHaskellBit `setBitIf` safeImports-    langExtBits =-          FfiBit                      `xoptBit` LangExt.ForeignFunctionInterface-      .|. InterruptibleFfiBit         `xoptBit` LangExt.InterruptibleFFI-      .|. CApiFfiBit                  `xoptBit` LangExt.CApiFFI-      .|. ArrowsBit                   `xoptBit` LangExt.Arrows-      .|. ThBit                       `xoptBit` LangExt.TemplateHaskell-      .|. ThQuotesBit                 `xoptBit` LangExt.TemplateHaskellQuotes-      .|. QqBit                       `xoptBit` LangExt.QuasiQuotes-      .|. IpBit                       `xoptBit` LangExt.ImplicitParams-      .|. OverloadedLabelsBit         `xoptBit` LangExt.OverloadedLabels-      .|. ExplicitForallBit           `xoptBit` LangExt.ExplicitForAll-      .|. BangPatBit                  `xoptBit` LangExt.BangPatterns-      .|. MagicHashBit                `xoptBit` LangExt.MagicHash-      .|. RecursiveDoBit              `xoptBit` LangExt.RecursiveDo-      .|. UnicodeSyntaxBit            `xoptBit` LangExt.UnicodeSyntax-      .|. UnboxedTuplesBit            `xoptBit` LangExt.UnboxedTuples-      .|. UnboxedSumsBit              `xoptBit` LangExt.UnboxedSums-      .|. DatatypeContextsBit         `xoptBit` LangExt.DatatypeContexts-      .|. TransformComprehensionsBit  `xoptBit` LangExt.TransformListComp-      .|. MonadComprehensionsBit      `xoptBit` LangExt.MonadComprehensions-      .|. AlternativeLayoutRuleBit    `xoptBit` LangExt.AlternativeLayoutRule-      .|. ALRTransitionalBit          `xoptBit` LangExt.AlternativeLayoutRuleTransitional-      .|. RelaxedLayoutBit            `xoptBit` LangExt.RelaxedLayout-      .|. NondecreasingIndentationBit `xoptBit` LangExt.NondecreasingIndentation-      .|. TraditionalRecordSyntaxBit  `xoptBit` LangExt.TraditionalRecordSyntax-      .|. ExplicitNamespacesBit       `xoptBit` LangExt.ExplicitNamespaces-      .|. LambdaCaseBit               `xoptBit` LangExt.LambdaCase-      .|. BinaryLiteralsBit           `xoptBit` LangExt.BinaryLiterals-      .|. NegativeLiteralsBit         `xoptBit` LangExt.NegativeLiterals-      .|. HexFloatLiteralsBit         `xoptBit` LangExt.HexFloatLiterals-      .|. PatternSynonymsBit          `xoptBit` LangExt.PatternSynonyms-      .|. TypeApplicationsBit         `xoptBit` LangExt.TypeApplications-      .|. StaticPointersBit           `xoptBit` LangExt.StaticPointers-      .|. NumericUnderscoresBit       `xoptBit` LangExt.NumericUnderscores-      .|. StarIsTypeBit               `xoptBit` LangExt.StarIsType-      .|. BlockArgumentsBit           `xoptBit` LangExt.BlockArguments-      .|. NPlusKPatternsBit           `xoptBit` LangExt.NPlusKPatterns-      .|. DoAndIfThenElseBit          `xoptBit` LangExt.DoAndIfThenElse-      .|. MultiWayIfBit               `xoptBit` LangExt.MultiWayIf-      .|. GadtSyntaxBit               `xoptBit` LangExt.GADTSyntax-      .|. ImportQualifiedPostBit      `xoptBit` LangExt.ImportQualifiedPost-    optBits =-          HaddockBit        `setBitIf` isHaddock-      .|. RawTokenStreamBit `setBitIf` rawTokStream-      .|. UsePosPragsBit    `setBitIf` usePosPrags--    xoptBit bit ext = bit `setBitIf` EnumSet.member ext extensionFlags--    setBitIf :: ExtBits -> Bool -> ExtsBitmap-    b `setBitIf` cond | cond      = xbit b-                      | otherwise = 0---- | Extracts the flag information needed for parsing-mkParserFlags :: DynFlags -> ParserFlags-mkParserFlags =-  mkParserFlags'-    <$> DynFlags.warningFlags-    <*> DynFlags.extensionFlags-    <*> DynFlags.thisPackage-    <*> safeImportsOn-    <*> gopt Opt_Haddock-    <*> gopt Opt_KeepRawTokenStream-    <*> const True---- | Creates a parse state from a 'DynFlags' value-mkPState :: DynFlags -> StringBuffer -> RealSrcLoc -> PState-mkPState flags = mkPStatePure (mkParserFlags flags)---- | Creates a parse state from a 'ParserFlags' value-mkPStatePure :: ParserFlags -> StringBuffer -> RealSrcLoc -> PState-mkPStatePure options buf loc =-  PState {-      buffer        = buf,-      options       = options,-      messages      = const emptyMessages,-      tab_first     = Nothing,-      tab_count     = 0,-      last_tk       = Nothing,-      last_loc      = mkPsSpan init_loc init_loc,-      last_len      = 0,-      loc           = init_loc,-      context       = [],-      lex_state     = [bol, 0],-      srcfiles      = [],-      alr_pending_implicit_tokens = [],-      alr_next_token = Nothing,-      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,--- disambiguate, or rearrange them, and we do so in the PV monad which cannot consume--- input but can report parsing errors, check for extension bits, and accumulate--- parsing annotations. Both P and PV are instances of MonadP.------ MonadP grants us convenient overloading. The other option is to have separate operations--- for each monad: addErrorP vs addErrorPV, getBitP vs getBitPV, and so on.----class Monad m => MonadP m where-  -- | Add a non-fatal error. Use this when the parser can produce a result-  --   despite the error.-  ---  --   For example, when GHC encounters a @forall@ in a type,-  --   but @-XExplicitForAll@ is disabled, the parser constructs @ForAllTy@-  --   as if @-XExplicitForAll@ was enabled, adding a non-fatal error to-  --   the accumulator.-  ---  --   Control flow wise, non-fatal errors act like warnings: they are added-  --   to the accumulator and parsing continues. This allows GHC to report-  --   more than one parse error per file.-  ---  addError :: SrcSpan -> SDoc -> m ()-  -- | Add a warning to the accumulator.-  --   Use 'getMessages' to get the accumulated warnings.-  addWarning :: WarningFlag -> SrcSpan -> SDoc -> m ()-  -- | Add a fatal error. This will be the last error reported by the parser, and-  --   the parser will not produce any result, ending in a 'PFailed' state.-  addFatalError :: SrcSpan -> SDoc -> m a-  -- | Check if a given flag is currently set in the bitmap.-  getBit :: ExtBits -> m Bool-  -- | Given a location and a list of AddAnn, apply them all to the location.-  addAnnotation :: SrcSpan          -- SrcSpan of enclosing AST construct-                -> AnnKeywordId     -- The first two parameters are the key-                -> SrcSpan          -- The location of the keyword itself-                -> m ()--appendError-  :: SrcSpan-  -> SDoc-  -> (DynFlags -> Messages)-  -> (DynFlags -> Messages)-appendError srcspan msg m =-  \d ->-    let (ws, es) = m d-        errormsg = mkErrMsg d srcspan alwaysQualify msg-        es' = es `snocBag` errormsg-    in (ws, es')--appendWarning-  :: ParserFlags-  -> WarningFlag-  -> SrcSpan-  -> SDoc-  -> (DynFlags -> Messages)-  -> (DynFlags -> Messages)-appendWarning o option srcspan warning m =-  \d ->-    let (ws, es) = m d-        warning' = makeIntoWarning (Reason option) $-           mkWarnMsg d srcspan alwaysQualify warning-        ws' = if warnopt option o then ws `snocBag` warning' else ws-    in (ws', es)--instance MonadP P where-  addError srcspan msg-   = P $ \s@PState{messages=m} ->-             POk s{messages=appendError srcspan msg m} ()-  addWarning option srcspan warning-   = P $ \s@PState{messages=m, options=o} ->-             POk s{messages=appendWarning o option srcspan warning m} ()-  addFatalError span msg =-    addError span msg >> P PFailed-  getBit ext = P $ \s -> let b =  ext `xtest` pExtsBitmap (options s)-                         in b `seq` POk s b-  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)--addTabWarning :: RealSrcSpan -> P ()-addTabWarning srcspan- = P $ \s@PState{tab_first=tf, tab_count=tc, options=o} ->-       let tf' = if isJust tf then tf else Just srcspan-           tc' = tc + 1-           s' = if warnopt Opt_WarnTabs o-                then s{tab_first = tf', tab_count = tc'}-                else s-       in POk s' ()--mkTabWarning :: PState -> DynFlags -> Maybe ErrMsg-mkTabWarning PState{tab_first=tf, tab_count=tc} d =-  let middle = if tc == 1-        then text ""-        else text ", and in" <+> speakNOf (tc - 1) (text "further location")-      message = text "Tab character found here"-                <> middle-                <> text "."-                $+$ text "Please use spaces instead."-  in fmap (\s -> makeIntoWarning (Reason Opt_WarnTabs) $-                 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.-getErrorMessages :: PState -> DynFlags -> ErrorMessages-getErrorMessages PState{messages=m} d =-  let (_, es) = m d in es---- | Get the warnings and errors accumulated so far.---   Does not take -Werror into account.-getMessages :: PState -> DynFlags -> Messages-getMessages p@PState{messages=m} d =-  let (ws, es) = m d-      tabwarning = mkTabWarning p d-      ws' = maybe ws (`consBag` ws) tabwarning-  in (ws', es)--getContext :: P [LayoutContext]-getContext = P $ \s@PState{context=ctx} -> POk s ctx--setContext :: [LayoutContext] -> P ()-setContext ctx = P $ \s -> POk s{context=ctx} ()--popContext :: P ()-popContext = P $ \ s@(PState{ buffer = buf, options = o, context = ctx,-                              last_len = len, last_loc = last_loc }) ->-  case ctx of-        (_:tl) ->-          POk s{ context = tl } ()-        []     ->-          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 (psRealSpan loc)) gen_semic : ctx} ()---- This is only used at the outer level of a module when the 'module' keyword is--- missing.-pushModuleContext :: P ()-pushModuleContext = pushCurrentContext generateSemic--getOffside :: P (Ordering, Bool)-getOffside = P $ \s@PState{last_loc=loc, context=stk} ->-                let offs = srcSpanStartCol (psRealSpan loc) in-                let ord = case stk of-                            Layout n gen_semic : _ ->-                              --trace ("layout: " ++ show n ++ ", offs: " ++ show offs) $-                              (compare offs n, gen_semic)-                            _ ->-                              (GT, dontGenerateSemic)-                in POk s ord---- ------------------------------------------------------------------------------ Construct a parse error--srcParseErr-  :: ParserFlags-  -> StringBuffer       -- current buffer (placed just after the last token)-  -> Int                -- length of the previous token-  -> MsgDoc-srcParseErr options buf len-  = if null token-         then text "parse error (possibly incorrect indentation or mismatched brackets)"-         else text "parse error on input" <+> quotes (text token)-              $$ ppWhen (not th_enabled && token == "$") -- #7396-                        (text "Perhaps you intended to use TemplateHaskell")-              $$ ppWhen (token == "<-")-                        (if mdoInLast100-                           then text "Perhaps you intended to use RecursiveDo"-                           else text "Perhaps this statement should be within a 'do' block?")-              $$ ppWhen (token == "=" && doInLast100) -- #15849-                        (text "Perhaps you need a 'let' in a 'do' block?"-                         $$ text "e.g. 'let x = 5' instead of 'x = 5'")-              $$ ppWhen (not ps_enabled && pattern == "pattern ") -- #12429-                        (text "Perhaps you intended to use PatternSynonyms")-  where token = lexemeToString (offsetBytes (-len) buf) len-        pattern = decodePrevNChars 8 buf-        last100 = decodePrevNChars 100 buf-        doInLast100 = "do" `isInfixOf` last100-        mdoInLast100 = "mdo" `isInfixOf` last100-        th_enabled = ThQuotesBit `xtest` pExtsBitmap options-        ps_enabled = PatternSynonymsBit `xtest` pExtsBitmap options---- Report a parse failure, giving the span of the previous token as--- the location of the error.  This is the entry point for errors--- detected during parsing.-srcParseFail :: P a-srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len,-                            last_loc = last_loc } ->-    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.-lexError :: String -> P a-lexError str = do-  loc <- getRealSrcLoc-  (AI end buf) <- getInput-  reportLexError loc (psRealLoc end) buf str---- -------------------------------------------------------------------------------- This is the top-level function: called from the parser each time a--- new token is to be read from the input.--lexer, lexerDbg :: Bool -> (Located Token -> P a) -> P a--lexer queueComments cont = do-  alr <- getBit AlternativeLayoutRuleBit-  let lexTokenFun = if alr then lexTokenAlr else lexToken-  (L span tok) <- lexTokenFun-  --trace ("token: " ++ show tok) $ do--  if (queueComments && isDocComment tok)-    then queueComment (L (psRealSpan span) tok)-    else return ()--  if (queueComments && isComment 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 (PsLocated Token)-lexTokenAlr = do mPending <- popPendingImplicitToken-                 t <- case mPending of-                      Nothing ->-                          do mNext <- popNextToken-                             t <- case mNext of-                                  Nothing -> lexToken-                                  Just next -> return next-                             alternativeLayoutRuleToken t-                      Just t ->-                          return t-                 setAlrLastLoc (getLoc t)-                 case unLoc t of-                     ITwhere -> setAlrExpectingOCurly (Just ALRLayoutWhere)-                     ITlet   -> setAlrExpectingOCurly (Just ALRLayoutLet)-                     ITof    -> setAlrExpectingOCurly (Just ALRLayoutOf)-                     ITlcase -> setAlrExpectingOCurly (Just ALRLayoutOf)-                     ITdo    -> setAlrExpectingOCurly (Just ALRLayoutDo)-                     ITmdo   -> setAlrExpectingOCurly (Just ALRLayoutDo)-                     ITrec   -> setAlrExpectingOCurly (Just ALRLayoutDo)-                     _       -> return ()-                 return t--alternativeLayoutRuleToken :: PsLocated Token -> P (PsLocated Token)-alternativeLayoutRuleToken t-    = do context <- getALRContext-         lastLoc <- getAlrLastLoc-         mExpectingOCurly <- getAlrExpectingOCurly-         transitional <- getBit ALRTransitionalBit-         justClosedExplicitLetBlock <- getJustClosedExplicitLetBlock-         setJustClosedExplicitLetBlock False-         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) ->-                 do setAlrExpectingOCurly Nothing-                    let isLet = case alrLayout of-                                ALRLayoutLet -> True-                                _ -> False-                    setALRContext (ALRNoLayout (containsCommas ITocurly) isLet : context)-                    return t-             -- ...and makes this case unnecessary-             {--             -- I think our implicit open-curly handling is slightly-             -- different to John's, in how it interacts with newlines-             -- and "in"-             (ITocurly, _, Just _) ->-                 do setAlrExpectingOCurly Nothing-                    setNextToken t-                    lexTokenAlr-             -}-             (_, ALRLayout _ col : _ls, Just expectingOCurly)-              | (thisCol > col) ||-                (thisCol == col &&-                 isNonDecreasingIndentation expectingOCurly) ->-                 do setAlrExpectingOCurly Nothing-                    setALRContext (ALRLayout expectingOCurly thisCol : context)-                    setNextToken t-                    return (L thisLoc ITvocurly)-              | otherwise ->-                 do setAlrExpectingOCurly Nothing-                    setPendingImplicitTokens [L lastLoc ITvccurly]-                    setNextToken t-                    return (L lastLoc ITvocurly)-             (_, _, Just expectingOCurly) ->-                 do setAlrExpectingOCurly Nothing-                    setALRContext (ALRLayout expectingOCurly thisCol : context)-                    setNextToken t-                    return (L thisLoc ITvocurly)-             -- We do the [] cases earlier than in the spec, as we-             -- have an actual EOF token-             (ITeof, ALRLayout _ _ : ls, _) ->-                 do setALRContext ls-                    setNextToken t-                    return (L thisLoc ITvccurly)-             (ITeof, _, _) ->-                 return t-             -- the other ITeof case omitted; general case below covers it-             (ITin, _, _)-              | justClosedExplicitLetBlock ->-                 return t-             (ITin, ALRLayout ALRLayoutLet _ : ls, _)-              | newLine ->-                 do setPendingImplicitTokens [t]-                    setALRContext ls-                    return (L thisLoc ITvccurly)-             -- This next case is to handle a transitional issue:-             (ITwhere, ALRLayout _ col : ls, _)-              | newLine && thisCol == col && transitional ->-                 do addWarning Opt_WarnAlternativeLayoutRuleTransitional-                               (mkSrcSpanPs thisLoc)-                               (transitionalAlternativeLayoutWarning-                                    "`where' clause at the same depth as implicit layout block")-                    setALRContext ls-                    setNextToken t-                    -- Note that we use lastLoc, as we may need to close-                    -- more layouts, or give a semicolon-                    return (L lastLoc ITvccurly)-             -- This next case is to handle a transitional issue:-             (ITvbar, ALRLayout _ col : ls, _)-              | newLine && thisCol == col && transitional ->-                 do addWarning Opt_WarnAlternativeLayoutRuleTransitional-                               (mkSrcSpanPs thisLoc)-                               (transitionalAlternativeLayoutWarning-                                    "`|' at the same depth as implicit layout block")-                    setALRContext ls-                    setNextToken t-                    -- Note that we use lastLoc, as we may need to close-                    -- more layouts, or give a semicolon-                    return (L lastLoc ITvccurly)-             (_, ALRLayout _ col : ls, _)-              | newLine && thisCol == col ->-                 do setNextToken t-                    let loc = psSpanStart thisLoc-                        zeroWidthLoc = mkPsSpan loc loc-                    return (L zeroWidthLoc ITsemi)-              | newLine && thisCol < col ->-                 do setALRContext ls-                    setNextToken t-                    -- Note that we use lastLoc, as we may need to close-                    -- more layouts, or give a semicolon-                    return (L lastLoc ITvccurly)-             -- We need to handle close before open, as 'then' is both-             -- an open and a close-             (u, _, _)-              | isALRclose u ->-                 case context of-                 ALRLayout _ _ : ls ->-                     do setALRContext ls-                        setNextToken t-                        return (L thisLoc ITvccurly)-                 ALRNoLayout _ isLet : ls ->-                     do let ls' = if isALRopen u-                                     then ALRNoLayout (containsCommas u) False : ls-                                     else ls-                        setALRContext ls'-                        when isLet $ setJustClosedExplicitLetBlock True-                        return t-                 [] ->-                     do let ls = if isALRopen u-                                    then [ALRNoLayout (containsCommas u) False]-                                    else []-                        setALRContext ls-                        -- XXX This is an error in John's code, but-                        -- it looks reachable to me at first glance-                        return t-             (u, _, _)-              | isALRopen u ->-                 do setALRContext (ALRNoLayout (containsCommas u) False : context)-                    return t-             (ITin, ALRLayout ALRLayoutLet _ : ls, _) ->-                 do setALRContext ls-                    setPendingImplicitTokens [t]-                    return (L thisLoc ITvccurly)-             (ITin, ALRLayout _ _ : ls, _) ->-                 do setALRContext ls-                    setNextToken t-                    return (L thisLoc ITvccurly)-             -- the other ITin case omitted; general case below covers it-             (ITcomma, ALRLayout _ _ : ls, _)-              | topNoLayoutContainsCommas ls ->-                 do setALRContext ls-                    setNextToken t-                    return (L thisLoc ITvccurly)-             (ITwhere, ALRLayout ALRLayoutDo _ : ls, _) ->-                 do setALRContext ls-                    setPendingImplicitTokens [t]-                    return (L thisLoc ITvccurly)-             -- the other ITwhere case omitted; general case below covers it-             (_, _, _) -> return t--transitionalAlternativeLayoutWarning :: String -> SDoc-transitionalAlternativeLayoutWarning msg-    = text "transitional layout will not be accepted in the future:"-   $$ text msg--isALRopen :: Token -> Bool-isALRopen ITcase          = True-isALRopen ITif            = True-isALRopen ITthen          = True-isALRopen IToparen        = True-isALRopen ITobrack        = True-isALRopen ITocurly        = True--- GHC Extensions:-isALRopen IToubxparen     = True-isALRopen _               = False--isALRclose :: Token -> Bool-isALRclose ITof     = True-isALRclose ITthen   = True-isALRclose ITelse   = True-isALRclose ITcparen = True-isALRclose ITcbrack = True-isALRclose ITccurly = True--- GHC Extensions:-isALRclose ITcubxparen = True-isALRclose _        = False--isNonDecreasingIndentation :: ALRLayout -> Bool-isNonDecreasingIndentation ALRLayoutDo = True-isNonDecreasingIndentation _           = False--containsCommas :: Token -> Bool-containsCommas IToparen = True-containsCommas ITobrack = True--- John doesn't have {} as containing commas, but records contain them,--- which caused a problem parsing Cabal's Distribution.Simple.InstallDirs--- (defaultInstallDirs).-containsCommas ITocurly = True--- GHC Extensions:-containsCommas IToubxparen = True-containsCommas _        = False--topNoLayoutContainsCommas :: [ALRContext] -> Bool-topNoLayoutContainsCommas [] = False-topNoLayoutContainsCommas (ALRLayout _ _ : ls) = topNoLayoutContainsCommas ls-topNoLayoutContainsCommas (ALRNoLayout b _ : _) = b--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 = mkPsSpan loc1 loc1-        setEofPos (psRealSpan span)-        setLastToken span 0-        return (L span ITeof)-    AlexError (AI loc2 buf) ->-        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 = mkPsSpan loc1 end-        let bytes = byteDiff buf buf2-        span `seq` setLastToken span bytes-        lt <- t span buf bytes-        let lt' = unLoc lt-        unless (isComment lt') (setLastTk lt')-        return lt--reportLexError :: RealSrcLoc -> RealSrcLoc -> StringBuffer -> [Char] -> P a-reportLexError loc1 loc2 buf str-  | atEnd buf = failLocMsgP loc1 loc2 (str ++ " at end of input")-  | otherwise =-  let c = fst (nextChar buf)-  in if c == '\0' -- decoding errors are mapped to '\0', see utf8DecodeChar#-     then failLocMsgP loc2 loc2 (str ++ " (UTF-8 decoding error)")-     else failLocMsgP loc1 loc2 (str ++ " at character " ++ show c)--lexTokenStream :: StringBuffer -> RealSrcLoc -> DynFlags -> ParseResult [Located Token]-lexTokenStream buf loc dflags = unP go initState{ options = opts' }-    where dflags' = gopt_set (gopt_unset dflags Opt_Haddock) Opt_KeepRawTokenStream-          initState@PState{ options = opts } = mkPState dflags' buf loc-          opts' = opts{ pExtsBitmap = complement (xbit UsePosPragsBit) .&. pExtsBitmap opts }-          go = do-            ltok <- lexer False return-            case ltok of-              L _ ITeof -> return []-              _ -> liftM (ltok:) go--linePrags = Map.singleton "line" linePrag--fileHeaderPrags = Map.fromList([("options", lex_string_prag IToptions_prag),-                                 ("options_ghc", lex_string_prag IToptions_prag),-                                 ("options_haddock", lex_string_prag ITdocOptions),-                                 ("language", token ITlanguage_prag),-                                 ("include", lex_string_prag ITinclude_prag)])--ignoredPrags = Map.fromList (map ignored pragmas)-               where ignored opt = (opt, nested_comment lexToken)-                     impls = ["hugs", "nhc98", "jhc", "yhc", "catch", "derive"]-                     options_pragmas = map ("options_" ++) impls-                     -- CFILES is a hugs-only thing.-                     pragmas = options_pragmas ++ ["cfiles", "contract"]--oneWordPrags = Map.fromList [-     ("rules", rulePrag),-     ("inline",-         strtoken (\s -> (ITinline_prag (SourceText s) Inline FunLike))),-     ("inlinable",-         strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),-     ("inlineable",-         strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),-                                    -- Spelling variant-     ("notinline",-         strtoken (\s -> (ITinline_prag (SourceText s) NoInline FunLike))),-     ("specialize", strtoken (\s -> ITspec_prag (SourceText s))),-     ("source", strtoken (\s -> ITsource_prag (SourceText s))),-     ("warning", strtoken (\s -> ITwarning_prag (SourceText s))),-     ("deprecated", strtoken (\s -> ITdeprecated_prag (SourceText s))),-     ("scc", strtoken (\s -> ITscc_prag (SourceText s))),-     ("generated", strtoken (\s -> ITgenerated_prag (SourceText s))),-     ("core", strtoken (\s -> ITcore_prag (SourceText s))),-     ("unpack", strtoken (\s -> ITunpack_prag (SourceText s))),-     ("nounpack", strtoken (\s -> ITnounpack_prag (SourceText s))),-     ("ann", strtoken (\s -> ITann_prag (SourceText s))),-     ("minimal", strtoken (\s -> ITminimal_prag (SourceText s))),-     ("overlaps", strtoken (\s -> IToverlaps_prag (SourceText s))),-     ("overlappable", strtoken (\s -> IToverlappable_prag (SourceText s))),-     ("overlapping", strtoken (\s -> IToverlapping_prag (SourceText s))),-     ("incoherent", strtoken (\s -> ITincoherent_prag (SourceText s))),-     ("ctype", strtoken (\s -> ITctype (SourceText s))),-     ("complete", strtoken (\s -> ITcomplete_prag (SourceText s))),-     ("column", columnPrag)-     ]--twoWordPrags = Map.fromList [-     ("inline conlike",-         strtoken (\s -> (ITinline_prag (SourceText s) Inline ConLike))),-     ("notinline conlike",-         strtoken (\s -> (ITinline_prag (SourceText s) NoInline ConLike))),-     ("specialize inline",-         strtoken (\s -> (ITspec_inline_prag (SourceText s) True))),-     ("specialize notinline",-         strtoken (\s -> (ITspec_inline_prag (SourceText s) False)))-     ]--dispatch_pragmas :: Map String Action -> Action-dispatch_pragmas prags span buf len = case Map.lookup (clean_pragma (lexemeToString buf len)) prags of-                                       Just found -> found span buf len-                                       Nothing -> lexError "unknown pragma"--known_pragma :: Map String Action -> AlexAccPred ExtsBitmap-known_pragma prags _ (AI _ startbuf) _ (AI _ curbuf)- = isKnown && nextCharIsNot curbuf pragmaNameChar-    where l = lexemeToString startbuf (byteDiff startbuf curbuf)-          isKnown = isJust $ Map.lookup (clean_pragma l) prags-          pragmaNameChar c = isAlphaNum c || c == '_'--clean_pragma :: String -> String-clean_pragma prag = canon_ws (map toLower (unprefix prag))-                    where unprefix prag' = case stripPrefix "{-#" prag' of-                                             Just rest -> rest-                                             Nothing -> prag'-                          canonical prag' = case prag' of-                                              "noinline" -> "notinline"-                                              "specialise" -> "specialize"-                                              "constructorlike" -> "conlike"-                                              _ -> prag'-                          canon_ws s = unwords (map canonical (words s))----{--%************************************************************************-%*                                                                      *-        Helper functions for generating annotations in the parser-%*                                                                      *-%************************************************************************--}---- | Encapsulated call to addAnnotation, requiring only the SrcSpan of---   the AST construct the annotation belongs to; together with the---   AnnKeywordId, this is the key of the annotation map.------   This type is useful for places in the parser where it is not yet---   known what SrcSpan an annotation should be added to.  The most---   common situation is when we are parsing a list: the annotations---   need to be associated with the AST element that *contains* the---   list, not the list itself.  'AddAnn' lets us defer adding the---   annotations until we finish parsing the list and are now parsing---   the enclosing element; we then apply the 'AddAnn' to associate---   the annotations.  Another common situation is where a common fragment of---   the AST has been factored out but there is no separate AST node for---   this fragment (this occurs in class and data declarations). In this---   case, the annotation belongs to the parent data declaration.------   The usual way an 'AddAnn' is created is using the 'mj' ("make jump")---   function, and then it can be discharged using the 'ams' function.-data AddAnn = AddAnn AnnKeywordId SrcSpan--addAnnotationOnly :: RealSrcSpan -> AnnKeywordId -> RealSrcSpan -> P ()-addAnnotationOnly l a v = P $ \s -> POk s {-  annotations = ((l,a), [v]) : annotations s-  } ()---- |Given a 'SrcSpan' that surrounds a 'HsPar' or 'HsParTy', generate--- 'AddAnn' values for the opening and closing bordering on the start--- and end of the span-mkParensApiAnn :: SrcSpan -> [AddAnn]-mkParensApiAnn (UnhelpfulSpan _)  = []-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 = RealSrcSpan (mkRealSrcSpan (realSrcSpanStart ss)        (mkRealSrcLoc f sl (sc+1))) Nothing-    lc = RealSrcSpan (mkRealSrcSpan (mkRealSrcLoc f el (ec - 1)) (realSrcSpanEnd ss))        Nothing--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 :: RealSrcSpan -> P ()-allocateCommentsP ss = P $ \s ->-  let (comment_q', newAnns) = allocateComments ss (comment_q s) in-    POk s {-       comment_q = comment_q'-     , annotations_comments = newAnns ++ (annotations_comments s)-     } ()--allocateComments-  :: RealSrcSpan-  -> [RealLocated AnnotationComment]-  -> ([RealLocated AnnotationComment], [(RealSrcSpan,[RealLocated AnnotationComment])])-allocateComments ss comment_q =-  let-    (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)]-  in-    (comment_q', newAnns)---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)-commentToAnnotation (L l (ITdocSection n s))    = L l (AnnDocSection n s)-commentToAnnotation (L l (ITdocOptions s))      = L l (AnnDocOptions s)-commentToAnnotation (L l (ITlineComment s))     = L l (AnnLineComment s)-commentToAnnotation (L l (ITblockComment s))    = L l (AnnBlockComment s)-commentToAnnotation _                           = panic "commentToAnnotation"---- -----------------------------------------------------------------------isComment :: Token -> Bool-isComment (ITlineComment     _)   = True-isComment (ITblockComment    _)   = True-isComment _ = False--isDocComment :: Token -> Bool-isDocComment (ITdocCommentNext  _)   = True-isDocComment (ITdocCommentPrev  _)   = True-isDocComment (ITdocCommentNamed _)   = True-isDocComment (ITdocSection      _ _) = True-isDocComment (ITdocOptions      _)   = True-isDocComment _ = False---bol,column_prag,layout,layout_do,layout_if,layout_left,line_prag1,line_prag1a,line_prag2,line_prag2a,option_prags :: Int-bol = 1-column_prag = 2-layout = 3-layout_do = 4-layout_if = 5-layout_left = 6-line_prag1 = 7-line_prag1a = 8-line_prag2 = 9-line_prag2a = 10-option_prags = 11-alex_action_1 =  warnTab -alex_action_2 =  nested_comment lexToken -alex_action_3 =  lineCommentToken -alex_action_4 =  lineCommentToken -alex_action_5 =  lineCommentToken -alex_action_6 =  lineCommentToken -alex_action_7 =  lineCommentToken -alex_action_8 =  lineCommentToken -alex_action_10 =  begin line_prag1 -alex_action_11 =  begin line_prag1 -alex_action_14 =  do_bol -alex_action_15 =  hopefully_open_brace -alex_action_17 =  begin line_prag1 -alex_action_18 =  new_layout_context True dontGenerateSemic ITvbar -alex_action_19 =  pop -alex_action_20 =  new_layout_context True  generateSemic ITvocurly -alex_action_21 =  new_layout_context False generateSemic ITvocurly -alex_action_22 =  do_layout_left -alex_action_23 =  begin bol -alex_action_24 =  dispatch_pragmas linePrags -alex_action_25 =  setLineAndFile line_prag1a -alex_action_26 =  failLinePrag1 -alex_action_27 =  popLinePrag1 -alex_action_28 =  setLineAndFile line_prag2a -alex_action_29 =  pop -alex_action_30 =  setColumn -alex_action_31 =  dispatch_pragmas twoWordPrags -alex_action_32 =  dispatch_pragmas oneWordPrags -alex_action_33 =  dispatch_pragmas ignoredPrags -alex_action_34 =  endPrag -alex_action_35 =  dispatch_pragmas fileHeaderPrags -alex_action_36 =  nested_comment lexToken -alex_action_37 =  warnThen Opt_WarnUnrecognisedPragmas (text "Unrecognised pragma")-                    (nested_comment lexToken) -alex_action_38 =  multiline_doc_comment -alex_action_39 =  nested_doc_comment -alex_action_40 =  token (ITopenExpQuote NoE NormalSyntax) -alex_action_41 =  token (ITopenTExpQuote NoE) -alex_action_42 =  token (ITopenExpQuote HasE NormalSyntax) -alex_action_43 =  token (ITopenTExpQuote HasE) -alex_action_44 =  token ITopenPatQuote -alex_action_45 =  layout_token ITopenDecQuote -alex_action_46 =  token ITopenTypQuote -alex_action_47 =  token (ITcloseQuote NormalSyntax) -alex_action_48 =  token ITcloseTExpQuote -alex_action_49 =  lex_quasiquote_tok -alex_action_50 =  lex_qquasiquote_tok -alex_action_51 =  token (ITopenExpQuote NoE UnicodeSyntax) -alex_action_52 =  token (ITcloseQuote UnicodeSyntax) -alex_action_53 =  special (IToparenbar NormalSyntax) -alex_action_54 =  special (ITcparenbar NormalSyntax) -alex_action_55 =  special (IToparenbar UnicodeSyntax) -alex_action_56 =  special (ITcparenbar UnicodeSyntax) -alex_action_57 =  skip_one_varid ITdupipvarid -alex_action_58 =  skip_one_varid ITlabelvarid -alex_action_59 =  token IToubxparen -alex_action_60 =  token ITcubxparen -alex_action_61 =  special IToparen -alex_action_62 =  special ITcparen -alex_action_63 =  special ITobrack -alex_action_64 =  special ITcbrack -alex_action_65 =  special ITcomma -alex_action_66 =  special ITsemi -alex_action_67 =  special ITbackquote -alex_action_68 =  open_brace -alex_action_69 =  close_brace -alex_action_70 =  idtoken qvarid -alex_action_71 =  idtoken qconid -alex_action_72 =  varid -alex_action_73 =  idtoken conid -alex_action_74 =  idtoken qvarid -alex_action_75 =  idtoken qconid -alex_action_76 =  varid -alex_action_77 =  idtoken conid -alex_action_78 =  varsym_tight_infix -alex_action_79 =  varsym_prefix -alex_action_80 =  varsym_suffix -alex_action_81 =  varsym_loose_infix -alex_action_82 =  idtoken qvarsym -alex_action_83 =  idtoken qconsym -alex_action_84 =  consym -alex_action_85 =  tok_num positive 0 0 decimal -alex_action_86 =  tok_num positive 2 2 binary -alex_action_87 =  tok_num positive 2 2 octal -alex_action_88 =  tok_num positive 2 2 hexadecimal -alex_action_89 =  tok_num negative 1 1 decimal -alex_action_90 =  tok_num negative 3 3 binary -alex_action_91 =  tok_num negative 3 3 octal -alex_action_92 =  tok_num negative 3 3 hexadecimal -alex_action_93 =  tok_frac 0 tok_float -alex_action_94 =  tok_frac 0 tok_float -alex_action_95 =  tok_frac 0 tok_hex_float -alex_action_96 =  tok_frac 0 tok_hex_float -alex_action_97 =  tok_primint positive 0 1 decimal -alex_action_98 =  tok_primint positive 2 3 binary -alex_action_99 =  tok_primint positive 2 3 octal -alex_action_100 =  tok_primint positive 2 3 hexadecimal -alex_action_101 =  tok_primint negative 1 2 decimal -alex_action_102 =  tok_primint negative 3 4 binary -alex_action_103 =  tok_primint negative 3 4 octal -alex_action_104 =  tok_primint negative 3 4 hexadecimal -alex_action_105 =  tok_primword 0 2 decimal -alex_action_106 =  tok_primword 2 4 binary -alex_action_107 =  tok_primword 2 4 octal -alex_action_108 =  tok_primword 2 4 hexadecimal -alex_action_109 =  tok_frac 1 tok_primfloat -alex_action_110 =  tok_frac 2 tok_primdouble -alex_action_111 =  lex_char_tok -alex_action_112 =  lex_string_tok -{-# LINE 1 "templates/GenericTemplate.hs" #-}--- -------------------------------------------------------------------------------- ALEX TEMPLATE------ This code is in the PUBLIC DOMAIN; you may copy it freely and use--- it for any purpose whatsoever.---- -------------------------------------------------------------------------------- INTERNALS and main scanner engine-------------------- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.-#if __GLASGOW_HASKELL__ > 706-#define GTE(n,m) (tagToEnum# (n >=# m))-#define EQ(n,m) (tagToEnum# (n ==# m))-#else-#define GTE(n,m) (n >=# m)-#define EQ(n,m) (n ==# m)-#endif--------------------data AlexAddr = AlexA# Addr#--- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.-#if __GLASGOW_HASKELL__ < 503-uncheckedShiftL# = shiftL#-#endif--{-# INLINE alexIndexInt16OffAddr #-}-alexIndexInt16OffAddr (AlexA# arr) off =-#ifdef WORDS_BIGENDIAN-  narrow16Int# i-  where-        i    = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)-        high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))-        low  = int2Word# (ord# (indexCharOffAddr# arr off'))-        off' = off *# 2#-#else-  indexInt16OffAddr# arr off-#endif------{-# INLINE alexIndexInt32OffAddr #-}-alexIndexInt32OffAddr (AlexA# arr) off =-#ifdef WORDS_BIGENDIAN-  narrow32Int# i-  where-   i    = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`-                     (b2 `uncheckedShiftL#` 16#) `or#`-                     (b1 `uncheckedShiftL#` 8#) `or#` b0)-   b3   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))-   b2   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))-   b1   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))-   b0   = int2Word# (ord# (indexCharOffAddr# arr off'))-   off' = off *# 4#-#else-  indexInt32OffAddr# arr off-#endif-------#if __GLASGOW_HASKELL__ < 503-quickIndex arr i = arr ! i-#else--- GHC >= 503, unsafeAt is available from Data.Array.Base.-quickIndex = unsafeAt-#endif------- -------------------------------------------------------------------------------- Main lexing routines--data AlexReturn a-  = AlexEOF-  | AlexError  !AlexInput-  | AlexSkip   !AlexInput !Int-  | AlexToken  !AlexInput !Int a---- alexScan :: AlexInput -> StartCode -> AlexReturn a-alexScan input__ (I# (sc))-  = alexScanUser undefined input__ (I# (sc))--alexScanUser user__ input__ (I# (sc))-  = case alex_scan_tkn user__ input__ 0# input__ sc AlexNone of-  (AlexNone, input__') ->-    case alexGetByte input__ of-      Nothing ->----                                   AlexEOF-      Just _ ->----                                   AlexError input__'--  (AlexLastSkip input__'' len, _) ->----    AlexSkip input__'' len--  (AlexLastAcc k input__''' len, _) ->----    AlexToken input__''' len (alex_actions ! k)----- Push the input through the DFA, remembering the most recent accepting--- state it encountered.--alex_scan_tkn user__ orig_input len input__ s last_acc =-  input__ `seq` -- strict in the input-  let-  new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))-  in-  new_acc `seq`-  case alexGetByte input__ of-     Nothing -> (new_acc, input__)-     Just (c, new_input) ->----      case fromIntegral c of { (I# (ord_c)) ->-        let-                base   = alexIndexInt32OffAddr alex_base s-                offset = (base +# ord_c)-                check  = alexIndexInt16OffAddr alex_check offset--                new_s = if GTE(offset,0#) && EQ(check,ord_c)-                          then alexIndexInt16OffAddr alex_table offset-                          else alexIndexInt16OffAddr alex_deflt s-        in-        case new_s of-            -1# -> (new_acc, input__)-                -- on an error, we want to keep the input *before* the-                -- character that failed, not after.-            _ -> alex_scan_tkn user__ orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)-                                                -- note that the length is increased ONLY if this is the 1st byte in a char encoding)-                        new_input new_s new_acc-      }-  where-        check_accs (AlexAccNone) = last_acc-        check_accs (AlexAcc a  ) = AlexLastAcc a input__ (I# (len))-        check_accs (AlexAccSkip) = AlexLastSkip  input__ (I# (len))--        check_accs (AlexAccPred a predx rest)-           | predx user__ orig_input (I# (len)) input__-           = AlexLastAcc a input__ (I# (len))-           | otherwise-           = check_accs rest-        check_accs (AlexAccSkipPred predx rest)-           | predx user__ orig_input (I# (len)) input__-           = AlexLastSkip input__ (I# (len))-           | otherwise-           = check_accs rest---data AlexLastAcc-  = AlexNone-  | AlexLastAcc !Int !AlexInput !Int-  | AlexLastSkip     !AlexInput !Int--data AlexAcc user-  = AlexAccNone-  | AlexAcc Int-  | AlexAccSkip--  | AlexAccPred Int (AlexAccPred user) (AlexAcc user)-  | AlexAccSkipPred (AlexAccPred user) (AlexAcc user)--type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool---- -------------------------------------------------------------------------------- Predicates on a rule--alexAndPred p1 p2 user__ in1 len in2-  = p1 user__ in1 len in2 && p2 user__ in1 len in2----alexPrevCharIsPred :: Char -> AlexAccPred _-alexPrevCharIs c _ input__ _ _ = c == alexInputPrevChar input__--alexPrevCharMatches f _ input__ _ _ = f (alexInputPrevChar input__)----alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _-alexPrevCharIsOneOf arr _ input__ _ _ = arr ! alexInputPrevChar input__----alexRightContext :: Int -> AlexAccPred _-alexRightContext (I# (sc)) user__ _ _ input__ =-     case alex_scan_tkn user__ input__ 0# input__ sc AlexNone of-          (AlexNone, _) -> False-          _ -> True-        -- TODO: there's no need to find the longest-        -- match when checking the right context, just-        -- the first match will do.-
− ghc-lib/stage0/compiler/build/Parser.hs 
@@ -1,12972 +0,0 @@-{-# OPTIONS_GHC -w #-}-{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}-#if __GLASGOW_HASKELL__ >= 710-{-# OPTIONS_GHC -XPartialTypeSignatures #-}-#endif-{-# LANGUAGE ViewPatterns #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE LambdaCase #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE GADTs #-}-{-# LANGUAGE ScopedTypeVariables #-}---- | This module provides the generated Happy parser for Haskell. It exports--- a number of parsers which may be used in any library that uses the GHC API.--- A common usage pattern is to initialize the parser state with a given string--- and then parse that string:------ @---     runParser :: DynFlags -> String -> P a -> ParseResult a---     runParser flags str parser = unP parser parseState---     where---       filename = "\<interactive\>"---       location = mkRealSrcLoc (mkFastString filename) 1 1---       buffer = stringToStringBuffer str---       parseState = mkPState flags buffer location--- @-module Parser (parseModule, parseSignature, parseImport, parseStatement, parseBackpack,-               parseDeclaration, parseExpression, parsePattern,-               parseTypeSignature,-               parseStmt, parseIdentifier,-               parseType, parseHeader) where---- base-import Control.Monad    ( unless, liftM, when, (<=<) )-import GHC.Exts-import Data.Char-import Data.Maybe       ( maybeToList )-import Control.Monad    ( mplus )-import Control.Applicative ((<$))-import qualified Prelude---- compiler/hsSyn-import GHC.Hs---- compiler/main-import GHC.Driver.Phases  ( HscSource(..) )-import GHC.Driver.Types   ( IsBootInterface, WarningTxt(..) )-import GHC.Driver.Session-import GHC.Driver.Backpack.Syntax-import UnitInfo---- compiler/utils-import OrdList-import BooleanFormula   ( BooleanFormula(..), LBooleanFormula(..), mkTrue )-import FastString-import Maybes           ( isJust, orElse )-import Outputable---- compiler/basicTypes-import GHC.Types.Name.Reader-import GHC.Types.Name.Occurrence ( varName, dataName, tcClsName, tvName, startsWithUnderscore )-import GHC.Core.DataCon          ( DataCon, dataConName )-import GHC.Types.SrcLoc-import GHC.Types.Module-import GHC.Types.Basic---- compiler/types-import GHC.Core.Type    ( funTyCon )-import GHC.Core.Class   ( FunDep )---- compiler/parser-import RdrHsSyn-import Lexer-import HaddockUtils-import ApiAnnotation---- compiler/typecheck-import TcEvidence       ( emptyTcEvBinds )---- compiler/prelude-import GHC.Types.ForeignCall-import TysPrim          ( eqPrimTyCon )-import TysWiredIn       ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,-                          unboxedUnitTyCon, unboxedUnitDataCon,-                          listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR )---- compiler/utils-import Util             ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )-import GhcPrelude-import qualified Data.Array as Happy_Data_Array-import qualified Data.Bits as Bits-import qualified GHC.Exts as Happy_GHC_Exts-import Control.Applicative(Applicative(..))-import Control.Monad (ap)---- parser produced by Happy Version 1.19.12--newtype HappyAbsSyn  = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = Happy_GHC_Exts.Any-#else-type HappyAny = forall a . a-#endif-newtype HappyWrap16 = HappyWrap16 (Located RdrName)-happyIn16 :: (Located RdrName) -> (HappyAbsSyn )-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap16 x)-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn ) -> HappyWrap16-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut16 #-}-newtype HappyWrap17 = HappyWrap17 ([LHsUnit PackageName])-happyIn17 :: ([LHsUnit PackageName]) -> (HappyAbsSyn )-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap17 x)-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn ) -> HappyWrap17-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut17 #-}-newtype HappyWrap18 = HappyWrap18 (OrdList (LHsUnit PackageName))-happyIn18 :: (OrdList (LHsUnit PackageName)) -> (HappyAbsSyn )-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap18 x)-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn ) -> HappyWrap18-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut18 #-}-newtype HappyWrap19 = HappyWrap19 (LHsUnit PackageName)-happyIn19 :: (LHsUnit PackageName) -> (HappyAbsSyn )-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap19 x)-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn ) -> HappyWrap19-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut19 #-}-newtype HappyWrap20 = HappyWrap20 (LHsUnitId PackageName)-happyIn20 :: (LHsUnitId PackageName) -> (HappyAbsSyn )-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap20 x)-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn ) -> HappyWrap20-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut20 #-}-newtype HappyWrap21 = HappyWrap21 (OrdList (LHsModuleSubst PackageName))-happyIn21 :: (OrdList (LHsModuleSubst PackageName)) -> (HappyAbsSyn )-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap21 x)-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn ) -> HappyWrap21-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut21 #-}-newtype HappyWrap22 = HappyWrap22 (LHsModuleSubst PackageName)-happyIn22 :: (LHsModuleSubst PackageName) -> (HappyAbsSyn )-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap22 x)-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn ) -> HappyWrap22-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut22 #-}-newtype HappyWrap23 = HappyWrap23 (LHsModuleId PackageName)-happyIn23 :: (LHsModuleId PackageName) -> (HappyAbsSyn )-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap23 x)-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn ) -> HappyWrap23-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut23 #-}-newtype HappyWrap24 = HappyWrap24 (Located PackageName)-happyIn24 :: (Located PackageName) -> (HappyAbsSyn )-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap24 x)-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn ) -> HappyWrap24-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut24 #-}-newtype HappyWrap25 = HappyWrap25 (Located FastString)-happyIn25 :: (Located FastString) -> (HappyAbsSyn )-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap25 x)-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn ) -> HappyWrap25-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut25 #-}-newtype HappyWrap26 = HappyWrap26 (Located FastString)-happyIn26 :: (Located FastString) -> (HappyAbsSyn )-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap26 x)-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn ) -> HappyWrap26-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut26 #-}-newtype HappyWrap27 = HappyWrap27 (Maybe [LRenaming])-happyIn27 :: (Maybe [LRenaming]) -> (HappyAbsSyn )-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap27 x)-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn ) -> HappyWrap27-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut27 #-}-newtype HappyWrap28 = HappyWrap28 (OrdList LRenaming)-happyIn28 :: (OrdList LRenaming) -> (HappyAbsSyn )-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap28 x)-{-# INLINE happyIn28 #-}-happyOut28 :: (HappyAbsSyn ) -> HappyWrap28-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut28 #-}-newtype HappyWrap29 = HappyWrap29 (LRenaming)-happyIn29 :: (LRenaming) -> (HappyAbsSyn )-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap29 x)-{-# INLINE happyIn29 #-}-happyOut29 :: (HappyAbsSyn ) -> HappyWrap29-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut29 #-}-newtype HappyWrap30 = HappyWrap30 (OrdList (LHsUnitDecl PackageName))-happyIn30 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap30 x)-{-# INLINE happyIn30 #-}-happyOut30 :: (HappyAbsSyn ) -> HappyWrap30-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut30 #-}-newtype HappyWrap31 = HappyWrap31 (OrdList (LHsUnitDecl PackageName))-happyIn31 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap31 x)-{-# INLINE happyIn31 #-}-happyOut31 :: (HappyAbsSyn ) -> HappyWrap31-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut31 #-}-newtype HappyWrap32 = HappyWrap32 (LHsUnitDecl PackageName)-happyIn32 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap32 x)-{-# INLINE happyIn32 #-}-happyOut32 :: (HappyAbsSyn ) -> HappyWrap32-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut32 #-}-newtype HappyWrap33 = HappyWrap33 (Located HsModule)-happyIn33 :: (Located HsModule) -> (HappyAbsSyn )-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap33 x)-{-# INLINE happyIn33 #-}-happyOut33 :: (HappyAbsSyn ) -> HappyWrap33-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut33 #-}-newtype HappyWrap34 = HappyWrap34 (Located HsModule)-happyIn34 :: (Located HsModule) -> (HappyAbsSyn )-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap34 x)-{-# INLINE happyIn34 #-}-happyOut34 :: (HappyAbsSyn ) -> HappyWrap34-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut34 #-}-newtype HappyWrap35 = HappyWrap35 (Maybe LHsDocString)-happyIn35 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap35 x)-{-# INLINE happyIn35 #-}-happyOut35 :: (HappyAbsSyn ) -> HappyWrap35-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut35 #-}-newtype HappyWrap36 = HappyWrap36 (())-happyIn36 :: (()) -> (HappyAbsSyn )-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap36 x)-{-# INLINE happyIn36 #-}-happyOut36 :: (HappyAbsSyn ) -> HappyWrap36-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut36 #-}-newtype HappyWrap37 = HappyWrap37 (())-happyIn37 :: (()) -> (HappyAbsSyn )-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap37 x)-{-# INLINE happyIn37 #-}-happyOut37 :: (HappyAbsSyn ) -> HappyWrap37-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut37 #-}-newtype HappyWrap38 = HappyWrap38 (Maybe (Located WarningTxt))-happyIn38 :: (Maybe (Located WarningTxt)) -> (HappyAbsSyn )-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap38 x)-{-# INLINE happyIn38 #-}-happyOut38 :: (HappyAbsSyn ) -> HappyWrap38-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut38 #-}-newtype HappyWrap39 = HappyWrap39 (([AddAnn]-             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))-happyIn39 :: (([AddAnn]-             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap39 x)-{-# INLINE happyIn39 #-}-happyOut39 :: (HappyAbsSyn ) -> HappyWrap39-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut39 #-}-newtype HappyWrap40 = HappyWrap40 (([AddAnn]-             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))-happyIn40 :: (([AddAnn]-             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap40 x)-{-# INLINE happyIn40 #-}-happyOut40 :: (HappyAbsSyn ) -> HappyWrap40-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut40 #-}-newtype HappyWrap41 = HappyWrap41 (([AddAnn]-             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))-happyIn41 :: (([AddAnn]-             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap41 x)-{-# INLINE happyIn41 #-}-happyOut41 :: (HappyAbsSyn ) -> HappyWrap41-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut41 #-}-newtype HappyWrap42 = HappyWrap42 (([LImportDecl GhcPs], [LHsDecl GhcPs]))-happyIn42 :: (([LImportDecl GhcPs], [LHsDecl GhcPs])) -> (HappyAbsSyn )-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap42 x)-{-# INLINE happyIn42 #-}-happyOut42 :: (HappyAbsSyn ) -> HappyWrap42-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut42 #-}-newtype HappyWrap43 = HappyWrap43 (Located HsModule)-happyIn43 :: (Located HsModule) -> (HappyAbsSyn )-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap43 x)-{-# INLINE happyIn43 #-}-happyOut43 :: (HappyAbsSyn ) -> HappyWrap43-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut43 #-}-newtype HappyWrap44 = HappyWrap44 ([LImportDecl GhcPs])-happyIn44 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap44 x)-{-# INLINE happyIn44 #-}-happyOut44 :: (HappyAbsSyn ) -> HappyWrap44-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut44 #-}-newtype HappyWrap45 = HappyWrap45 ([LImportDecl GhcPs])-happyIn45 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap45 x)-{-# INLINE happyIn45 #-}-happyOut45 :: (HappyAbsSyn ) -> HappyWrap45-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut45 #-}-newtype HappyWrap46 = HappyWrap46 ([LImportDecl GhcPs])-happyIn46 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap46 x)-{-# INLINE happyIn46 #-}-happyOut46 :: (HappyAbsSyn ) -> HappyWrap46-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut46 #-}-newtype HappyWrap47 = HappyWrap47 ([LImportDecl GhcPs])-happyIn47 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap47 x)-{-# INLINE happyIn47 #-}-happyOut47 :: (HappyAbsSyn ) -> HappyWrap47-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut47 #-}-newtype HappyWrap48 = HappyWrap48 ((Maybe (Located [LIE GhcPs])))-happyIn48 :: ((Maybe (Located [LIE GhcPs]))) -> (HappyAbsSyn )-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap48 x)-{-# INLINE happyIn48 #-}-happyOut48 :: (HappyAbsSyn ) -> HappyWrap48-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut48 #-}-newtype HappyWrap49 = HappyWrap49 (OrdList (LIE GhcPs))-happyIn49 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap49 x)-{-# INLINE happyIn49 #-}-happyOut49 :: (HappyAbsSyn ) -> HappyWrap49-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut49 #-}-newtype HappyWrap50 = HappyWrap50 (OrdList (LIE GhcPs))-happyIn50 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap50 x)-{-# INLINE happyIn50 #-}-happyOut50 :: (HappyAbsSyn ) -> HappyWrap50-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut50 #-}-newtype HappyWrap51 = HappyWrap51 (OrdList (LIE GhcPs))-happyIn51 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap51 x)-{-# INLINE happyIn51 #-}-happyOut51 :: (HappyAbsSyn ) -> HappyWrap51-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut51 #-}-newtype HappyWrap52 = HappyWrap52 (OrdList (LIE GhcPs))-happyIn52 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap52 x)-{-# INLINE happyIn52 #-}-happyOut52 :: (HappyAbsSyn ) -> HappyWrap52-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut52 #-}-newtype HappyWrap53 = HappyWrap53 (OrdList (LIE GhcPs))-happyIn53 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap53 x)-{-# INLINE happyIn53 #-}-happyOut53 :: (HappyAbsSyn ) -> HappyWrap53-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut53 #-}-newtype HappyWrap54 = HappyWrap54 (Located ([AddAnn],ImpExpSubSpec))-happyIn54 :: (Located ([AddAnn],ImpExpSubSpec)) -> (HappyAbsSyn )-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap54 x)-{-# INLINE happyIn54 #-}-happyOut54 :: (HappyAbsSyn ) -> HappyWrap54-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut54 #-}-newtype HappyWrap55 = HappyWrap55 (([AddAnn], [Located ImpExpQcSpec]))-happyIn55 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap55 x)-{-# INLINE happyIn55 #-}-happyOut55 :: (HappyAbsSyn ) -> HappyWrap55-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut55 #-}-newtype HappyWrap56 = HappyWrap56 (([AddAnn], [Located ImpExpQcSpec]))-happyIn56 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap56 x)-{-# INLINE happyIn56 #-}-happyOut56 :: (HappyAbsSyn ) -> HappyWrap56-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut56 #-}-newtype HappyWrap57 = HappyWrap57 (Located ([AddAnn], Located ImpExpQcSpec))-happyIn57 :: (Located ([AddAnn], Located ImpExpQcSpec)) -> (HappyAbsSyn )-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap57 x)-{-# INLINE happyIn57 #-}-happyOut57 :: (HappyAbsSyn ) -> HappyWrap57-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut57 #-}-newtype HappyWrap58 = HappyWrap58 (Located ImpExpQcSpec)-happyIn58 :: (Located ImpExpQcSpec) -> (HappyAbsSyn )-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap58 x)-{-# INLINE happyIn58 #-}-happyOut58 :: (HappyAbsSyn ) -> HappyWrap58-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut58 #-}-newtype HappyWrap59 = HappyWrap59 (Located RdrName)-happyIn59 :: (Located RdrName) -> (HappyAbsSyn )-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap59 x)-{-# INLINE happyIn59 #-}-happyOut59 :: (HappyAbsSyn ) -> HappyWrap59-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut59 #-}-newtype HappyWrap60 = HappyWrap60 ([AddAnn])-happyIn60 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap60 x)-{-# INLINE happyIn60 #-}-happyOut60 :: (HappyAbsSyn ) -> HappyWrap60-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut60 #-}-newtype HappyWrap61 = HappyWrap61 ([AddAnn])-happyIn61 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn61 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap61 x)-{-# INLINE happyIn61 #-}-happyOut61 :: (HappyAbsSyn ) -> HappyWrap61-happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut61 #-}-newtype HappyWrap62 = HappyWrap62 ([LImportDecl GhcPs])-happyIn62 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn62 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap62 x)-{-# INLINE happyIn62 #-}-happyOut62 :: (HappyAbsSyn ) -> HappyWrap62-happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut62 #-}-newtype HappyWrap63 = HappyWrap63 ([LImportDecl GhcPs])-happyIn63 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn63 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap63 x)-{-# INLINE happyIn63 #-}-happyOut63 :: (HappyAbsSyn ) -> HappyWrap63-happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut63 #-}-newtype HappyWrap64 = HappyWrap64 (LImportDecl GhcPs)-happyIn64 :: (LImportDecl GhcPs) -> (HappyAbsSyn )-happyIn64 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap64 x)-{-# INLINE happyIn64 #-}-happyOut64 :: (HappyAbsSyn ) -> HappyWrap64-happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut64 #-}-newtype HappyWrap65 = HappyWrap65 ((([AddAnn],SourceText),IsBootInterface))-happyIn65 :: ((([AddAnn],SourceText),IsBootInterface)) -> (HappyAbsSyn )-happyIn65 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap65 x)-{-# INLINE happyIn65 #-}-happyOut65 :: (HappyAbsSyn ) -> HappyWrap65-happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut65 #-}-newtype HappyWrap66 = HappyWrap66 (([AddAnn],Bool))-happyIn66 :: (([AddAnn],Bool)) -> (HappyAbsSyn )-happyIn66 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap66 x)-{-# INLINE happyIn66 #-}-happyOut66 :: (HappyAbsSyn ) -> HappyWrap66-happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut66 #-}-newtype HappyWrap67 = HappyWrap67 (([AddAnn],Maybe StringLiteral))-happyIn67 :: (([AddAnn],Maybe StringLiteral)) -> (HappyAbsSyn )-happyIn67 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap67 x)-{-# INLINE happyIn67 #-}-happyOut67 :: (HappyAbsSyn ) -> HappyWrap67-happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut67 #-}-newtype HappyWrap68 = HappyWrap68 (Maybe (Located Token))-happyIn68 :: (Maybe (Located Token)) -> (HappyAbsSyn )-happyIn68 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap68 x)-{-# INLINE happyIn68 #-}-happyOut68 :: (HappyAbsSyn ) -> HappyWrap68-happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut68 #-}-newtype HappyWrap69 = HappyWrap69 (([AddAnn],Located (Maybe (Located ModuleName))))-happyIn69 :: (([AddAnn],Located (Maybe (Located ModuleName)))) -> (HappyAbsSyn )-happyIn69 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap69 x)-{-# INLINE happyIn69 #-}-happyOut69 :: (HappyAbsSyn ) -> HappyWrap69-happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut69 #-}-newtype HappyWrap70 = HappyWrap70 (Located (Maybe (Bool, Located [LIE GhcPs])))-happyIn70 :: (Located (Maybe (Bool, Located [LIE GhcPs]))) -> (HappyAbsSyn )-happyIn70 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap70 x)-{-# INLINE happyIn70 #-}-happyOut70 :: (HappyAbsSyn ) -> HappyWrap70-happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut70 #-}-newtype HappyWrap71 = HappyWrap71 (Located (Bool, Located [LIE GhcPs]))-happyIn71 :: (Located (Bool, Located [LIE GhcPs])) -> (HappyAbsSyn )-happyIn71 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap71 x)-{-# INLINE happyIn71 #-}-happyOut71 :: (HappyAbsSyn ) -> HappyWrap71-happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut71 #-}-newtype HappyWrap72 = HappyWrap72 (Located (SourceText,Int))-happyIn72 :: (Located (SourceText,Int)) -> (HappyAbsSyn )-happyIn72 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap72 x)-{-# INLINE happyIn72 #-}-happyOut72 :: (HappyAbsSyn ) -> HappyWrap72-happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut72 #-}-newtype HappyWrap73 = HappyWrap73 (Located FixityDirection)-happyIn73 :: (Located FixityDirection) -> (HappyAbsSyn )-happyIn73 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap73 x)-{-# INLINE happyIn73 #-}-happyOut73 :: (HappyAbsSyn ) -> HappyWrap73-happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut73 #-}-newtype HappyWrap74 = HappyWrap74 (Located (OrdList (Located RdrName)))-happyIn74 :: (Located (OrdList (Located RdrName))) -> (HappyAbsSyn )-happyIn74 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap74 x)-{-# INLINE happyIn74 #-}-happyOut74 :: (HappyAbsSyn ) -> HappyWrap74-happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut74 #-}-newtype HappyWrap75 = HappyWrap75 (OrdList (LHsDecl GhcPs))-happyIn75 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )-happyIn75 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap75 x)-{-# INLINE happyIn75 #-}-happyOut75 :: (HappyAbsSyn ) -> HappyWrap75-happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut75 #-}-newtype HappyWrap76 = HappyWrap76 (OrdList (LHsDecl GhcPs))-happyIn76 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )-happyIn76 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap76 x)-{-# INLINE happyIn76 #-}-happyOut76 :: (HappyAbsSyn ) -> HappyWrap76-happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut76 #-}-newtype HappyWrap77 = HappyWrap77 (LHsDecl GhcPs)-happyIn77 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn77 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap77 x)-{-# INLINE happyIn77 #-}-happyOut77 :: (HappyAbsSyn ) -> HappyWrap77-happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut77 #-}-newtype HappyWrap78 = HappyWrap78 (LTyClDecl GhcPs)-happyIn78 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )-happyIn78 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap78 x)-{-# INLINE happyIn78 #-}-happyOut78 :: (HappyAbsSyn ) -> HappyWrap78-happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut78 #-}-newtype HappyWrap79 = HappyWrap79 (LTyClDecl GhcPs)-happyIn79 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )-happyIn79 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap79 x)-{-# INLINE happyIn79 #-}-happyOut79 :: (HappyAbsSyn ) -> HappyWrap79-happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut79 #-}-newtype HappyWrap80 = HappyWrap80 (LStandaloneKindSig GhcPs)-happyIn80 :: (LStandaloneKindSig GhcPs) -> (HappyAbsSyn )-happyIn80 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap80 x)-{-# INLINE happyIn80 #-}-happyOut80 :: (HappyAbsSyn ) -> HappyWrap80-happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut80 #-}-newtype HappyWrap81 = HappyWrap81 (Located [Located RdrName])-happyIn81 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn81 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap81 x)-{-# INLINE happyIn81 #-}-happyOut81 :: (HappyAbsSyn ) -> HappyWrap81-happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut81 #-}-newtype HappyWrap82 = HappyWrap82 (LInstDecl GhcPs)-happyIn82 :: (LInstDecl GhcPs) -> (HappyAbsSyn )-happyIn82 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap82 x)-{-# INLINE happyIn82 #-}-happyOut82 :: (HappyAbsSyn ) -> HappyWrap82-happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut82 #-}-newtype HappyWrap83 = HappyWrap83 (Maybe (Located OverlapMode))-happyIn83 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )-happyIn83 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap83 x)-{-# INLINE happyIn83 #-}-happyOut83 :: (HappyAbsSyn ) -> HappyWrap83-happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut83 #-}-newtype HappyWrap84 = HappyWrap84 (LDerivStrategy GhcPs)-happyIn84 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )-happyIn84 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap84 x)-{-# INLINE happyIn84 #-}-happyOut84 :: (HappyAbsSyn ) -> HappyWrap84-happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut84 #-}-newtype HappyWrap85 = HappyWrap85 (LDerivStrategy GhcPs)-happyIn85 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )-happyIn85 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap85 x)-{-# INLINE happyIn85 #-}-happyOut85 :: (HappyAbsSyn ) -> HappyWrap85-happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut85 #-}-newtype HappyWrap86 = HappyWrap86 (Maybe (LDerivStrategy GhcPs))-happyIn86 :: (Maybe (LDerivStrategy GhcPs)) -> (HappyAbsSyn )-happyIn86 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap86 x)-{-# INLINE happyIn86 #-}-happyOut86 :: (HappyAbsSyn ) -> HappyWrap86-happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut86 #-}-newtype HappyWrap87 = HappyWrap87 (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)))-happyIn87 :: (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )-happyIn87 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap87 x)-{-# INLINE happyIn87 #-}-happyOut87 :: (HappyAbsSyn ) -> HappyWrap87-happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut87 #-}-newtype HappyWrap88 = HappyWrap88 (LInjectivityAnn GhcPs)-happyIn88 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )-happyIn88 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap88 x)-{-# INLINE happyIn88 #-}-happyOut88 :: (HappyAbsSyn ) -> HappyWrap88-happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut88 #-}-newtype HappyWrap89 = HappyWrap89 (Located [Located RdrName])-happyIn89 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn89 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap89 x)-{-# INLINE happyIn89 #-}-happyOut89 :: (HappyAbsSyn ) -> HappyWrap89-happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut89 #-}-newtype HappyWrap90 = HappyWrap90 (Located ([AddAnn],FamilyInfo GhcPs))-happyIn90 :: (Located ([AddAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )-happyIn90 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap90 x)-{-# INLINE happyIn90 #-}-happyOut90 :: (HappyAbsSyn ) -> HappyWrap90-happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut90 #-}-newtype HappyWrap91 = HappyWrap91 (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]))-happyIn91 :: (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )-happyIn91 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap91 x)-{-# INLINE happyIn91 #-}-happyOut91 :: (HappyAbsSyn ) -> HappyWrap91-happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut91 #-}-newtype HappyWrap92 = HappyWrap92 (Located [LTyFamInstEqn GhcPs])-happyIn92 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )-happyIn92 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap92 x)-{-# INLINE happyIn92 #-}-happyOut92 :: (HappyAbsSyn ) -> HappyWrap92-happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut92 #-}-newtype HappyWrap93 = HappyWrap93 (Located ([AddAnn],TyFamInstEqn GhcPs))-happyIn93 :: (Located ([AddAnn],TyFamInstEqn GhcPs)) -> (HappyAbsSyn )-happyIn93 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap93 x)-{-# INLINE happyIn93 #-}-happyOut93 :: (HappyAbsSyn ) -> HappyWrap93-happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut93 #-}-newtype HappyWrap94 = HappyWrap94 (LHsDecl GhcPs)-happyIn94 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn94 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap94 x)-{-# INLINE happyIn94 #-}-happyOut94 :: (HappyAbsSyn ) -> HappyWrap94-happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut94 #-}-newtype HappyWrap95 = HappyWrap95 ([AddAnn])-happyIn95 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn95 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap95 x)-{-# INLINE happyIn95 #-}-happyOut95 :: (HappyAbsSyn ) -> HappyWrap95-happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut95 #-}-newtype HappyWrap96 = HappyWrap96 ([AddAnn])-happyIn96 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn96 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap96 x)-{-# INLINE happyIn96 #-}-happyOut96 :: (HappyAbsSyn ) -> HappyWrap96-happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut96 #-}-newtype HappyWrap97 = HappyWrap97 (LInstDecl GhcPs)-happyIn97 :: (LInstDecl GhcPs) -> (HappyAbsSyn )-happyIn97 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap97 x)-{-# INLINE happyIn97 #-}-happyOut97 :: (HappyAbsSyn ) -> HappyWrap97-happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut97 #-}-newtype HappyWrap98 = HappyWrap98 (Located (AddAnn, NewOrData))-happyIn98 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )-happyIn98 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap98 x)-{-# INLINE happyIn98 #-}-happyOut98 :: (HappyAbsSyn ) -> HappyWrap98-happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut98 #-}-newtype HappyWrap99 = HappyWrap99 (Located ([AddAnn], Maybe (LHsKind GhcPs)))-happyIn99 :: (Located ([AddAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )-happyIn99 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap99 x)-{-# INLINE happyIn99 #-}-happyOut99 :: (HappyAbsSyn ) -> HappyWrap99-happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut99 #-}-newtype HappyWrap100 = HappyWrap100 (Located ([AddAnn], LFamilyResultSig GhcPs))-happyIn100 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )-happyIn100 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap100 x)-{-# INLINE happyIn100 #-}-happyOut100 :: (HappyAbsSyn ) -> HappyWrap100-happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut100 #-}-newtype HappyWrap101 = HappyWrap101 (Located ([AddAnn], LFamilyResultSig GhcPs))-happyIn101 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )-happyIn101 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap101 x)-{-# INLINE happyIn101 #-}-happyOut101 :: (HappyAbsSyn ) -> HappyWrap101-happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut101 #-}-newtype HappyWrap102 = HappyWrap102 (Located ([AddAnn], ( LFamilyResultSig GhcPs-                                            , Maybe (LInjectivityAnn GhcPs))))-happyIn102 :: (Located ([AddAnn], ( LFamilyResultSig GhcPs-                                            , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )-happyIn102 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap102 x)-{-# INLINE happyIn102 #-}-happyOut102 :: (HappyAbsSyn ) -> HappyWrap102-happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut102 #-}-newtype HappyWrap103 = HappyWrap103 (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))-happyIn103 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )-happyIn103 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap103 x)-{-# INLINE happyIn103 #-}-happyOut103 :: (HappyAbsSyn ) -> HappyWrap103-happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut103 #-}-newtype HappyWrap104 = HappyWrap104 (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs)))-happyIn104 :: (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs))) -> (HappyAbsSyn )-happyIn104 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap104 x)-{-# INLINE happyIn104 #-}-happyOut104 :: (HappyAbsSyn ) -> HappyWrap104-happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut104 #-}-newtype HappyWrap105 = HappyWrap105 (Maybe (Located CType))-happyIn105 :: (Maybe (Located CType)) -> (HappyAbsSyn )-happyIn105 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap105 x)-{-# INLINE happyIn105 #-}-happyOut105 :: (HappyAbsSyn ) -> HappyWrap105-happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut105 #-}-newtype HappyWrap106 = HappyWrap106 (LDerivDecl GhcPs)-happyIn106 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )-happyIn106 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap106 x)-{-# INLINE happyIn106 #-}-happyOut106 :: (HappyAbsSyn ) -> HappyWrap106-happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut106 #-}-newtype HappyWrap107 = HappyWrap107 (LRoleAnnotDecl GhcPs)-happyIn107 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )-happyIn107 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap107 x)-{-# INLINE happyIn107 #-}-happyOut107 :: (HappyAbsSyn ) -> HappyWrap107-happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut107 #-}-newtype HappyWrap108 = HappyWrap108 (Located [Located (Maybe FastString)])-happyIn108 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )-happyIn108 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap108 x)-{-# INLINE happyIn108 #-}-happyOut108 :: (HappyAbsSyn ) -> HappyWrap108-happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut108 #-}-newtype HappyWrap109 = HappyWrap109 (Located [Located (Maybe FastString)])-happyIn109 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )-happyIn109 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap109 x)-{-# INLINE happyIn109 #-}-happyOut109 :: (HappyAbsSyn ) -> HappyWrap109-happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut109 #-}-newtype HappyWrap110 = HappyWrap110 (Located (Maybe FastString))-happyIn110 :: (Located (Maybe FastString)) -> (HappyAbsSyn )-happyIn110 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap110 x)-{-# INLINE happyIn110 #-}-happyOut110 :: (HappyAbsSyn ) -> HappyWrap110-happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut110 #-}-newtype HappyWrap111 = HappyWrap111 (LHsDecl GhcPs)-happyIn111 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn111 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap111 x)-{-# INLINE happyIn111 #-}-happyOut111 :: (HappyAbsSyn ) -> HappyWrap111-happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut111 #-}-newtype HappyWrap112 = HappyWrap112 ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))-happyIn112 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )-happyIn112 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap112 x)-{-# INLINE happyIn112 #-}-happyOut112 :: (HappyAbsSyn ) -> HappyWrap112-happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut112 #-}-newtype HappyWrap113 = HappyWrap113 ([Located RdrName])-happyIn113 :: ([Located RdrName]) -> (HappyAbsSyn )-happyIn113 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap113 x)-{-# INLINE happyIn113 #-}-happyOut113 :: (HappyAbsSyn ) -> HappyWrap113-happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut113 #-}-newtype HappyWrap114 = HappyWrap114 ([RecordPatSynField (Located RdrName)])-happyIn114 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )-happyIn114 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap114 x)-{-# INLINE happyIn114 #-}-happyOut114 :: (HappyAbsSyn ) -> HappyWrap114-happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut114 #-}-newtype HappyWrap115 = HappyWrap115 (Located ([AddAnn]-                         , Located (OrdList (LHsDecl GhcPs))))-happyIn115 :: (Located ([AddAnn]-                         , Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )-happyIn115 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap115 x)-{-# INLINE happyIn115 #-}-happyOut115 :: (HappyAbsSyn ) -> HappyWrap115-happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut115 #-}-newtype HappyWrap116 = HappyWrap116 (LSig GhcPs)-happyIn116 :: (LSig GhcPs) -> (HappyAbsSyn )-happyIn116 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap116 x)-{-# INLINE happyIn116 #-}-happyOut116 :: (HappyAbsSyn ) -> HappyWrap116-happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut116 #-}-newtype HappyWrap117 = HappyWrap117 (LHsDecl GhcPs)-happyIn117 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn117 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap117 x)-{-# INLINE happyIn117 #-}-happyOut117 :: (HappyAbsSyn ) -> HappyWrap117-happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut117 #-}-newtype HappyWrap118 = HappyWrap118 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))-happyIn118 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn118 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap118 x)-{-# INLINE happyIn118 #-}-happyOut118 :: (HappyAbsSyn ) -> HappyWrap118-happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut118 #-}-newtype HappyWrap119 = HappyWrap119 (Located ([AddAnn]-                     , OrdList (LHsDecl GhcPs)))-happyIn119 :: (Located ([AddAnn]-                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn119 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap119 x)-{-# INLINE happyIn119 #-}-happyOut119 :: (HappyAbsSyn ) -> HappyWrap119-happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut119 #-}-newtype HappyWrap120 = HappyWrap120 (Located ([AddAnn]-                       ,(OrdList (LHsDecl GhcPs))))-happyIn120 :: (Located ([AddAnn]-                       ,(OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )-happyIn120 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap120 x)-{-# INLINE happyIn120 #-}-happyOut120 :: (HappyAbsSyn ) -> HappyWrap120-happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut120 #-}-newtype HappyWrap121 = HappyWrap121 (Located (OrdList (LHsDecl GhcPs)))-happyIn121 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn121 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap121 x)-{-# INLINE happyIn121 #-}-happyOut121 :: (HappyAbsSyn ) -> HappyWrap121-happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut121 #-}-newtype HappyWrap122 = HappyWrap122 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))-happyIn122 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn122 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap122 x)-{-# INLINE happyIn122 #-}-happyOut122 :: (HappyAbsSyn ) -> HappyWrap122-happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut122 #-}-newtype HappyWrap123 = HappyWrap123 (Located ([AddAnn]-                     , OrdList (LHsDecl GhcPs)))-happyIn123 :: (Located ([AddAnn]-                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn123 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap123 x)-{-# INLINE happyIn123 #-}-happyOut123 :: (HappyAbsSyn ) -> HappyWrap123-happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut123 #-}-newtype HappyWrap124 = HappyWrap124 (Located ([AddAnn]-                        , OrdList (LHsDecl GhcPs)))-happyIn124 :: (Located ([AddAnn]-                        , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn124 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap124 x)-{-# INLINE happyIn124 #-}-happyOut124 :: (HappyAbsSyn ) -> HappyWrap124-happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut124 #-}-newtype HappyWrap125 = HappyWrap125 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))-happyIn125 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn125 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap125 x)-{-# INLINE happyIn125 #-}-happyOut125 :: (HappyAbsSyn ) -> HappyWrap125-happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut125 #-}-newtype HappyWrap126 = HappyWrap126 (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))))-happyIn126 :: (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )-happyIn126 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap126 x)-{-# INLINE happyIn126 #-}-happyOut126 :: (HappyAbsSyn ) -> HappyWrap126-happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut126 #-}-newtype HappyWrap127 = HappyWrap127 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))-happyIn127 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )-happyIn127 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap127 x)-{-# INLINE happyIn127 #-}-happyOut127 :: (HappyAbsSyn ) -> HappyWrap127-happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut127 #-}-newtype HappyWrap128 = HappyWrap128 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))-happyIn128 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )-happyIn128 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap128 x)-{-# INLINE happyIn128 #-}-happyOut128 :: (HappyAbsSyn ) -> HappyWrap128-happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut128 #-}-newtype HappyWrap129 = HappyWrap129 (OrdList (LRuleDecl GhcPs))-happyIn129 :: (OrdList (LRuleDecl GhcPs)) -> (HappyAbsSyn )-happyIn129 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap129 x)-{-# INLINE happyIn129 #-}-happyOut129 :: (HappyAbsSyn ) -> HappyWrap129-happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut129 #-}-newtype HappyWrap130 = HappyWrap130 (LRuleDecl GhcPs)-happyIn130 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )-happyIn130 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap130 x)-{-# INLINE happyIn130 #-}-happyOut130 :: (HappyAbsSyn ) -> HappyWrap130-happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut130 #-}-newtype HappyWrap131 = HappyWrap131 (([AddAnn],Maybe Activation))-happyIn131 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )-happyIn131 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap131 x)-{-# INLINE happyIn131 #-}-happyOut131 :: (HappyAbsSyn ) -> HappyWrap131-happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut131 #-}-newtype HappyWrap132 = HappyWrap132 ([AddAnn])-happyIn132 :: ([AddAnn]) -> (HappyAbsSyn )-happyIn132 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap132 x)-{-# INLINE happyIn132 #-}-happyOut132 :: (HappyAbsSyn ) -> HappyWrap132-happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut132 #-}-newtype HappyWrap133 = HappyWrap133 (([AddAnn]-                              ,Activation))-happyIn133 :: (([AddAnn]-                              ,Activation)) -> (HappyAbsSyn )-happyIn133 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap133 x)-{-# INLINE happyIn133 #-}-happyOut133 :: (HappyAbsSyn ) -> HappyWrap133-happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut133 #-}-newtype HappyWrap134 = HappyWrap134 (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs]))-happyIn134 :: (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])) -> (HappyAbsSyn )-happyIn134 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap134 x)-{-# INLINE happyIn134 #-}-happyOut134 :: (HappyAbsSyn ) -> HappyWrap134-happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut134 #-}-newtype HappyWrap135 = HappyWrap135 ([LRuleTyTmVar])-happyIn135 :: ([LRuleTyTmVar]) -> (HappyAbsSyn )-happyIn135 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap135 x)-{-# INLINE happyIn135 #-}-happyOut135 :: (HappyAbsSyn ) -> HappyWrap135-happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut135 #-}-newtype HappyWrap136 = HappyWrap136 (LRuleTyTmVar)-happyIn136 :: (LRuleTyTmVar) -> (HappyAbsSyn )-happyIn136 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap136 x)-{-# INLINE happyIn136 #-}-happyOut136 :: (HappyAbsSyn ) -> HappyWrap136-happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut136 #-}-newtype HappyWrap137 = HappyWrap137 (OrdList (LWarnDecl GhcPs))-happyIn137 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn137 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap137 x)-{-# INLINE happyIn137 #-}-happyOut137 :: (HappyAbsSyn ) -> HappyWrap137-happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut137 #-}-newtype HappyWrap138 = HappyWrap138 (OrdList (LWarnDecl GhcPs))-happyIn138 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn138 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap138 x)-{-# INLINE happyIn138 #-}-happyOut138 :: (HappyAbsSyn ) -> HappyWrap138-happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut138 #-}-newtype HappyWrap139 = HappyWrap139 (OrdList (LWarnDecl GhcPs))-happyIn139 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn139 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap139 x)-{-# INLINE happyIn139 #-}-happyOut139 :: (HappyAbsSyn ) -> HappyWrap139-happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut139 #-}-newtype HappyWrap140 = HappyWrap140 (OrdList (LWarnDecl GhcPs))-happyIn140 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn140 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap140 x)-{-# INLINE happyIn140 #-}-happyOut140 :: (HappyAbsSyn ) -> HappyWrap140-happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut140 #-}-newtype HappyWrap141 = HappyWrap141 (Located ([AddAnn],[Located StringLiteral]))-happyIn141 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )-happyIn141 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap141 x)-{-# INLINE happyIn141 #-}-happyOut141 :: (HappyAbsSyn ) -> HappyWrap141-happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut141 #-}-newtype HappyWrap142 = HappyWrap142 (Located (OrdList (Located StringLiteral)))-happyIn142 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )-happyIn142 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap142 x)-{-# INLINE happyIn142 #-}-happyOut142 :: (HappyAbsSyn ) -> HappyWrap142-happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut142 #-}-newtype HappyWrap143 = HappyWrap143 (LHsDecl GhcPs)-happyIn143 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn143 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap143 x)-{-# INLINE happyIn143 #-}-happyOut143 :: (HappyAbsSyn ) -> HappyWrap143-happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut143 #-}-newtype HappyWrap144 = HappyWrap144 (Located ([AddAnn],HsDecl GhcPs))-happyIn144 :: (Located ([AddAnn],HsDecl GhcPs)) -> (HappyAbsSyn )-happyIn144 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap144 x)-{-# INLINE happyIn144 #-}-happyOut144 :: (HappyAbsSyn ) -> HappyWrap144-happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut144 #-}-newtype HappyWrap145 = HappyWrap145 (Located CCallConv)-happyIn145 :: (Located CCallConv) -> (HappyAbsSyn )-happyIn145 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap145 x)-{-# INLINE happyIn145 #-}-happyOut145 :: (HappyAbsSyn ) -> HappyWrap145-happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut145 #-}-newtype HappyWrap146 = HappyWrap146 (Located Safety)-happyIn146 :: (Located Safety) -> (HappyAbsSyn )-happyIn146 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap146 x)-{-# INLINE happyIn146 #-}-happyOut146 :: (HappyAbsSyn ) -> HappyWrap146-happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut146 #-}-newtype HappyWrap147 = HappyWrap147 (Located ([AddAnn]-                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)))-happyIn147 :: (Located ([AddAnn]-                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )-happyIn147 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap147 x)-{-# INLINE happyIn147 #-}-happyOut147 :: (HappyAbsSyn ) -> HappyWrap147-happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut147 #-}-newtype HappyWrap148 = HappyWrap148 (([AddAnn], Maybe (LHsType GhcPs)))-happyIn148 :: (([AddAnn], Maybe (LHsType GhcPs))) -> (HappyAbsSyn )-happyIn148 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap148 x)-{-# INLINE happyIn148 #-}-happyOut148 :: (HappyAbsSyn ) -> HappyWrap148-happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut148 #-}-newtype HappyWrap149 = HappyWrap149 (([AddAnn], Maybe (Located RdrName)))-happyIn149 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )-happyIn149 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap149 x)-{-# INLINE happyIn149 #-}-happyOut149 :: (HappyAbsSyn ) -> HappyWrap149-happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut149 #-}-newtype HappyWrap150 = HappyWrap150 (LHsType GhcPs)-happyIn150 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn150 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap150 x)-{-# INLINE happyIn150 #-}-happyOut150 :: (HappyAbsSyn ) -> HappyWrap150-happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut150 #-}-newtype HappyWrap151 = HappyWrap151 (LHsType GhcPs)-happyIn151 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn151 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap151 x)-{-# INLINE happyIn151 #-}-happyOut151 :: (HappyAbsSyn ) -> HappyWrap151-happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut151 #-}-newtype HappyWrap152 = HappyWrap152 (Located [Located RdrName])-happyIn152 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn152 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap152 x)-{-# INLINE happyIn152 #-}-happyOut152 :: (HappyAbsSyn ) -> HappyWrap152-happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut152 #-}-newtype HappyWrap153 = HappyWrap153 ((OrdList (LHsSigType GhcPs)))-happyIn153 :: ((OrdList (LHsSigType GhcPs))) -> (HappyAbsSyn )-happyIn153 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap153 x)-{-# INLINE happyIn153 #-}-happyOut153 :: (HappyAbsSyn ) -> HappyWrap153-happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut153 #-}-newtype HappyWrap154 = HappyWrap154 (Located ([AddAnn], SourceText, SrcUnpackedness))-happyIn154 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )-happyIn154 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap154 x)-{-# INLINE happyIn154 #-}-happyOut154 :: (HappyAbsSyn ) -> HappyWrap154-happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut154 #-}-newtype HappyWrap155 = HappyWrap155 ((AddAnn, ForallVisFlag))-happyIn155 :: ((AddAnn, ForallVisFlag)) -> (HappyAbsSyn )-happyIn155 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap155 x)-{-# INLINE happyIn155 #-}-happyOut155 :: (HappyAbsSyn ) -> HappyWrap155-happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut155 #-}-newtype HappyWrap156 = HappyWrap156 (LHsType GhcPs)-happyIn156 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn156 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap156 x)-{-# INLINE happyIn156 #-}-happyOut156 :: (HappyAbsSyn ) -> HappyWrap156-happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut156 #-}-newtype HappyWrap157 = HappyWrap157 (LHsType GhcPs)-happyIn157 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn157 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap157 x)-{-# INLINE happyIn157 #-}-happyOut157 :: (HappyAbsSyn ) -> HappyWrap157-happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut157 #-}-newtype HappyWrap158 = HappyWrap158 (LHsType GhcPs)-happyIn158 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn158 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap158 x)-{-# INLINE happyIn158 #-}-happyOut158 :: (HappyAbsSyn ) -> HappyWrap158-happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut158 #-}-newtype HappyWrap159 = HappyWrap159 (LHsType GhcPs)-happyIn159 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn159 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap159 x)-{-# INLINE happyIn159 #-}-happyOut159 :: (HappyAbsSyn ) -> HappyWrap159-happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut159 #-}-newtype HappyWrap160 = HappyWrap160 (LHsContext GhcPs)-happyIn160 :: (LHsContext GhcPs) -> (HappyAbsSyn )-happyIn160 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap160 x)-{-# INLINE happyIn160 #-}-happyOut160 :: (HappyAbsSyn ) -> HappyWrap160-happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut160 #-}-newtype HappyWrap161 = HappyWrap161 (LHsContext GhcPs)-happyIn161 :: (LHsContext GhcPs) -> (HappyAbsSyn )-happyIn161 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap161 x)-{-# INLINE happyIn161 #-}-happyOut161 :: (HappyAbsSyn ) -> HappyWrap161-happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut161 #-}-newtype HappyWrap162 = HappyWrap162 (LHsType GhcPs)-happyIn162 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn162 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap162 x)-{-# INLINE happyIn162 #-}-happyOut162 :: (HappyAbsSyn ) -> HappyWrap162-happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut162 #-}-newtype HappyWrap163 = HappyWrap163 (LHsType GhcPs)-happyIn163 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn163 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap163 x)-{-# INLINE happyIn163 #-}-happyOut163 :: (HappyAbsSyn ) -> HappyWrap163-happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut163 #-}-newtype HappyWrap164 = HappyWrap164 (LHsType GhcPs)-happyIn164 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn164 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap164 x)-{-# INLINE happyIn164 #-}-happyOut164 :: (HappyAbsSyn ) -> HappyWrap164-happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut164 #-}-newtype HappyWrap165 = HappyWrap165 (Located [Located TyEl])-happyIn165 :: (Located [Located TyEl]) -> (HappyAbsSyn )-happyIn165 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap165 x)-{-# INLINE happyIn165 #-}-happyOut165 :: (HappyAbsSyn ) -> HappyWrap165-happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut165 #-}-newtype HappyWrap166 = HappyWrap166 (Located TyEl)-happyIn166 :: (Located TyEl) -> (HappyAbsSyn )-happyIn166 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap166 x)-{-# INLINE happyIn166 #-}-happyOut166 :: (HappyAbsSyn ) -> HappyWrap166-happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut166 #-}-newtype HappyWrap167 = HappyWrap167 (LHsType GhcPs)-happyIn167 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn167 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap167 x)-{-# INLINE happyIn167 #-}-happyOut167 :: (HappyAbsSyn ) -> HappyWrap167-happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut167 #-}-newtype HappyWrap168 = HappyWrap168 ([Located TyEl])-happyIn168 :: ([Located TyEl]) -> (HappyAbsSyn )-happyIn168 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap168 x)-{-# INLINE happyIn168 #-}-happyOut168 :: (HappyAbsSyn ) -> HappyWrap168-happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut168 #-}-newtype HappyWrap169 = HappyWrap169 (Located TyEl)-happyIn169 :: (Located TyEl) -> (HappyAbsSyn )-happyIn169 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap169 x)-{-# INLINE happyIn169 #-}-happyOut169 :: (HappyAbsSyn ) -> HappyWrap169-happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut169 #-}-newtype HappyWrap170 = HappyWrap170 (LHsType GhcPs)-happyIn170 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn170 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap170 x)-{-# INLINE happyIn170 #-}-happyOut170 :: (HappyAbsSyn ) -> HappyWrap170-happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut170 #-}-newtype HappyWrap171 = HappyWrap171 (LHsSigType GhcPs)-happyIn171 :: (LHsSigType GhcPs) -> (HappyAbsSyn )-happyIn171 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap171 x)-{-# INLINE happyIn171 #-}-happyOut171 :: (HappyAbsSyn ) -> HappyWrap171-happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut171 #-}-newtype HappyWrap172 = HappyWrap172 ([LHsSigType GhcPs])-happyIn172 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )-happyIn172 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap172 x)-{-# INLINE happyIn172 #-}-happyOut172 :: (HappyAbsSyn ) -> HappyWrap172-happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut172 #-}-newtype HappyWrap173 = HappyWrap173 ([LHsType GhcPs])-happyIn173 :: ([LHsType GhcPs]) -> (HappyAbsSyn )-happyIn173 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap173 x)-{-# INLINE happyIn173 #-}-happyOut173 :: (HappyAbsSyn ) -> HappyWrap173-happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut173 #-}-newtype HappyWrap174 = HappyWrap174 ([LHsType GhcPs])-happyIn174 :: ([LHsType GhcPs]) -> (HappyAbsSyn )-happyIn174 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap174 x)-{-# INLINE happyIn174 #-}-happyOut174 :: (HappyAbsSyn ) -> HappyWrap174-happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut174 #-}-newtype HappyWrap175 = HappyWrap175 ([LHsType GhcPs])-happyIn175 :: ([LHsType GhcPs]) -> (HappyAbsSyn )-happyIn175 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap175 x)-{-# INLINE happyIn175 #-}-happyOut175 :: (HappyAbsSyn ) -> HappyWrap175-happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut175 #-}-newtype HappyWrap176 = HappyWrap176 ([LHsTyVarBndr GhcPs])-happyIn176 :: ([LHsTyVarBndr GhcPs]) -> (HappyAbsSyn )-happyIn176 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap176 x)-{-# INLINE happyIn176 #-}-happyOut176 :: (HappyAbsSyn ) -> HappyWrap176-happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut176 #-}-newtype HappyWrap177 = HappyWrap177 (LHsTyVarBndr GhcPs)-happyIn177 :: (LHsTyVarBndr GhcPs) -> (HappyAbsSyn )-happyIn177 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap177 x)-{-# INLINE happyIn177 #-}-happyOut177 :: (HappyAbsSyn ) -> HappyWrap177-happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut177 #-}-newtype HappyWrap178 = HappyWrap178 (Located ([AddAnn],[Located (FunDep (Located RdrName))]))-happyIn178 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )-happyIn178 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap178 x)-{-# INLINE happyIn178 #-}-happyOut178 :: (HappyAbsSyn ) -> HappyWrap178-happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut178 #-}-newtype HappyWrap179 = HappyWrap179 (Located [Located (FunDep (Located RdrName))])-happyIn179 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )-happyIn179 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap179 x)-{-# INLINE happyIn179 #-}-happyOut179 :: (HappyAbsSyn ) -> HappyWrap179-happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut179 #-}-newtype HappyWrap180 = HappyWrap180 (Located (FunDep (Located RdrName)))-happyIn180 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )-happyIn180 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap180 x)-{-# INLINE happyIn180 #-}-happyOut180 :: (HappyAbsSyn ) -> HappyWrap180-happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut180 #-}-newtype HappyWrap181 = HappyWrap181 (Located [Located RdrName])-happyIn181 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn181 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap181 x)-{-# INLINE happyIn181 #-}-happyOut181 :: (HappyAbsSyn ) -> HappyWrap181-happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut181 #-}-newtype HappyWrap182 = HappyWrap182 (LHsKind GhcPs)-happyIn182 :: (LHsKind GhcPs) -> (HappyAbsSyn )-happyIn182 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap182 x)-{-# INLINE happyIn182 #-}-happyOut182 :: (HappyAbsSyn ) -> HappyWrap182-happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut182 #-}-newtype HappyWrap183 = HappyWrap183 (Located ([AddAnn]-                          ,[LConDecl GhcPs]))-happyIn183 :: (Located ([AddAnn]-                          ,[LConDecl GhcPs])) -> (HappyAbsSyn )-happyIn183 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap183 x)-{-# INLINE happyIn183 #-}-happyOut183 :: (HappyAbsSyn ) -> HappyWrap183-happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut183 #-}-newtype HappyWrap184 = HappyWrap184 (Located [LConDecl GhcPs])-happyIn184 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )-happyIn184 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap184 x)-{-# INLINE happyIn184 #-}-happyOut184 :: (HappyAbsSyn ) -> HappyWrap184-happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut184 #-}-newtype HappyWrap185 = HappyWrap185 (LConDecl GhcPs)-happyIn185 :: (LConDecl GhcPs) -> (HappyAbsSyn )-happyIn185 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap185 x)-{-# INLINE happyIn185 #-}-happyOut185 :: (HappyAbsSyn ) -> HappyWrap185-happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut185 #-}-newtype HappyWrap186 = HappyWrap186 (LConDecl GhcPs)-happyIn186 :: (LConDecl GhcPs) -> (HappyAbsSyn )-happyIn186 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap186 x)-{-# INLINE happyIn186 #-}-happyOut186 :: (HappyAbsSyn ) -> HappyWrap186-happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut186 #-}-newtype HappyWrap187 = HappyWrap187 (Located ([AddAnn],[LConDecl GhcPs]))-happyIn187 :: (Located ([AddAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )-happyIn187 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap187 x)-{-# INLINE happyIn187 #-}-happyOut187 :: (HappyAbsSyn ) -> HappyWrap187-happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut187 #-}-newtype HappyWrap188 = HappyWrap188 (Located [LConDecl GhcPs])-happyIn188 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )-happyIn188 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap188 x)-{-# INLINE happyIn188 #-}-happyOut188 :: (HappyAbsSyn ) -> HappyWrap188-happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut188 #-}-newtype HappyWrap189 = HappyWrap189 (LConDecl GhcPs)-happyIn189 :: (LConDecl GhcPs) -> (HappyAbsSyn )-happyIn189 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap189 x)-{-# INLINE happyIn189 #-}-happyOut189 :: (HappyAbsSyn ) -> HappyWrap189-happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut189 #-}-newtype HappyWrap190 = HappyWrap190 (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]))-happyIn190 :: (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])) -> (HappyAbsSyn )-happyIn190 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap190 x)-{-# INLINE happyIn190 #-}-happyOut190 :: (HappyAbsSyn ) -> HappyWrap190-happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut190 #-}-newtype HappyWrap191 = HappyWrap191 (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString))-happyIn191 :: (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)) -> (HappyAbsSyn )-happyIn191 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap191 x)-{-# INLINE happyIn191 #-}-happyOut191 :: (HappyAbsSyn ) -> HappyWrap191-happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut191 #-}-newtype HappyWrap192 = HappyWrap192 ([LConDeclField GhcPs])-happyIn192 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )-happyIn192 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap192 x)-{-# INLINE happyIn192 #-}-happyOut192 :: (HappyAbsSyn ) -> HappyWrap192-happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut192 #-}-newtype HappyWrap193 = HappyWrap193 ([LConDeclField GhcPs])-happyIn193 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )-happyIn193 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap193 x)-{-# INLINE happyIn193 #-}-happyOut193 :: (HappyAbsSyn ) -> HappyWrap193-happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut193 #-}-newtype HappyWrap194 = HappyWrap194 (LConDeclField GhcPs)-happyIn194 :: (LConDeclField GhcPs) -> (HappyAbsSyn )-happyIn194 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap194 x)-{-# INLINE happyIn194 #-}-happyOut194 :: (HappyAbsSyn ) -> HappyWrap194-happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut194 #-}-newtype HappyWrap195 = HappyWrap195 (HsDeriving GhcPs)-happyIn195 :: (HsDeriving GhcPs) -> (HappyAbsSyn )-happyIn195 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap195 x)-{-# INLINE happyIn195 #-}-happyOut195 :: (HappyAbsSyn ) -> HappyWrap195-happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut195 #-}-newtype HappyWrap196 = HappyWrap196 (HsDeriving GhcPs)-happyIn196 :: (HsDeriving GhcPs) -> (HappyAbsSyn )-happyIn196 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap196 x)-{-# INLINE happyIn196 #-}-happyOut196 :: (HappyAbsSyn ) -> HappyWrap196-happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut196 #-}-newtype HappyWrap197 = HappyWrap197 (LHsDerivingClause GhcPs)-happyIn197 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )-happyIn197 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap197 x)-{-# INLINE happyIn197 #-}-happyOut197 :: (HappyAbsSyn ) -> HappyWrap197-happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut197 #-}-newtype HappyWrap198 = HappyWrap198 (Located [LHsSigType GhcPs])-happyIn198 :: (Located [LHsSigType GhcPs]) -> (HappyAbsSyn )-happyIn198 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap198 x)-{-# INLINE happyIn198 #-}-happyOut198 :: (HappyAbsSyn ) -> HappyWrap198-happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut198 #-}-newtype HappyWrap199 = HappyWrap199 (LHsDecl GhcPs)-happyIn199 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn199 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap199 x)-{-# INLINE happyIn199 #-}-happyOut199 :: (HappyAbsSyn ) -> HappyWrap199-happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut199 #-}-newtype HappyWrap200 = HappyWrap200 (LDocDecl)-happyIn200 :: (LDocDecl) -> (HappyAbsSyn )-happyIn200 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap200 x)-{-# INLINE happyIn200 #-}-happyOut200 :: (HappyAbsSyn ) -> HappyWrap200-happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut200 #-}-newtype HappyWrap201 = HappyWrap201 (LHsDecl GhcPs)-happyIn201 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn201 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap201 x)-{-# INLINE happyIn201 #-}-happyOut201 :: (HappyAbsSyn ) -> HappyWrap201-happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut201 #-}-newtype HappyWrap202 = HappyWrap202 (LHsDecl GhcPs)-happyIn202 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn202 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap202 x)-{-# INLINE happyIn202 #-}-happyOut202 :: (HappyAbsSyn ) -> HappyWrap202-happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut202 #-}-newtype HappyWrap203 = HappyWrap203 (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))-happyIn203 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )-happyIn203 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap203 x)-{-# INLINE happyIn203 #-}-happyOut203 :: (HappyAbsSyn ) -> HappyWrap203-happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut203 #-}-newtype HappyWrap204 = HappyWrap204 (Located [LGRHS GhcPs (LHsExpr GhcPs)])-happyIn204 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn204 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap204 x)-{-# INLINE happyIn204 #-}-happyOut204 :: (HappyAbsSyn ) -> HappyWrap204-happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut204 #-}-newtype HappyWrap205 = HappyWrap205 (LGRHS GhcPs (LHsExpr GhcPs))-happyIn205 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )-happyIn205 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap205 x)-{-# INLINE happyIn205 #-}-happyOut205 :: (HappyAbsSyn ) -> HappyWrap205-happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut205 #-}-newtype HappyWrap206 = HappyWrap206 (LHsDecl GhcPs)-happyIn206 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn206 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap206 x)-{-# INLINE happyIn206 #-}-happyOut206 :: (HappyAbsSyn ) -> HappyWrap206-happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut206 #-}-newtype HappyWrap207 = HappyWrap207 (([AddAnn],Maybe Activation))-happyIn207 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )-happyIn207 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap207 x)-{-# INLINE happyIn207 #-}-happyOut207 :: (HappyAbsSyn ) -> HappyWrap207-happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut207 #-}-newtype HappyWrap208 = HappyWrap208 (([AddAnn],Activation))-happyIn208 :: (([AddAnn],Activation)) -> (HappyAbsSyn )-happyIn208 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap208 x)-{-# INLINE happyIn208 #-}-happyOut208 :: (HappyAbsSyn ) -> HappyWrap208-happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut208 #-}-newtype HappyWrap209 = HappyWrap209 (Located (HsSplice GhcPs))-happyIn209 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )-happyIn209 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap209 x)-{-# INLINE happyIn209 #-}-happyOut209 :: (HappyAbsSyn ) -> HappyWrap209-happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut209 #-}-newtype HappyWrap210 = HappyWrap210 (ECP)-happyIn210 :: (ECP) -> (HappyAbsSyn )-happyIn210 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap210 x)-{-# INLINE happyIn210 #-}-happyOut210 :: (HappyAbsSyn ) -> HappyWrap210-happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut210 #-}-newtype HappyWrap211 = HappyWrap211 (ECP)-happyIn211 :: (ECP) -> (HappyAbsSyn )-happyIn211 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap211 x)-{-# INLINE happyIn211 #-}-happyOut211 :: (HappyAbsSyn ) -> HappyWrap211-happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut211 #-}-newtype HappyWrap212 = HappyWrap212 (ECP)-happyIn212 :: (ECP) -> (HappyAbsSyn )-happyIn212 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap212 x)-{-# INLINE happyIn212 #-}-happyOut212 :: (HappyAbsSyn ) -> HappyWrap212-happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut212 #-}-newtype HappyWrap213 = HappyWrap213 (ECP)-happyIn213 :: (ECP) -> (HappyAbsSyn )-happyIn213 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap213 x)-{-# INLINE happyIn213 #-}-happyOut213 :: (HappyAbsSyn ) -> HappyWrap213-happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut213 #-}-newtype HappyWrap214 = HappyWrap214 (([Located Token],Bool))-happyIn214 :: (([Located Token],Bool)) -> (HappyAbsSyn )-happyIn214 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap214 x)-{-# INLINE happyIn214 #-}-happyOut214 :: (HappyAbsSyn ) -> HappyWrap214-happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut214 #-}-newtype HappyWrap215 = HappyWrap215 (Located ([AddAnn], HsPragE GhcPs))-happyIn215 :: (Located ([AddAnn], HsPragE GhcPs)) -> (HappyAbsSyn )-happyIn215 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap215 x)-{-# INLINE happyIn215 #-}-happyOut215 :: (HappyAbsSyn ) -> HappyWrap215-happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut215 #-}-newtype HappyWrap216 = HappyWrap216 (ECP)-happyIn216 :: (ECP) -> (HappyAbsSyn )-happyIn216 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap216 x)-{-# INLINE happyIn216 #-}-happyOut216 :: (HappyAbsSyn ) -> HappyWrap216-happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut216 #-}-newtype HappyWrap217 = HappyWrap217 (ECP)-happyIn217 :: (ECP) -> (HappyAbsSyn )-happyIn217 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap217 x)-{-# INLINE happyIn217 #-}-happyOut217 :: (HappyAbsSyn ) -> HappyWrap217-happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut217 #-}-newtype HappyWrap218 = HappyWrap218 (ECP)-happyIn218 :: (ECP) -> (HappyAbsSyn )-happyIn218 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap218 x)-{-# INLINE happyIn218 #-}-happyOut218 :: (HappyAbsSyn ) -> HappyWrap218-happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut218 #-}-newtype HappyWrap219 = HappyWrap219 (ECP)-happyIn219 :: (ECP) -> (HappyAbsSyn )-happyIn219 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap219 x)-{-# INLINE happyIn219 #-}-happyOut219 :: (HappyAbsSyn ) -> HappyWrap219-happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut219 #-}-newtype HappyWrap220 = HappyWrap220 (LHsExpr GhcPs)-happyIn220 :: (LHsExpr GhcPs) -> (HappyAbsSyn )-happyIn220 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap220 x)-{-# INLINE happyIn220 #-}-happyOut220 :: (HappyAbsSyn ) -> HappyWrap220-happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut220 #-}-newtype HappyWrap221 = HappyWrap221 (Located (HsSplice GhcPs))-happyIn221 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )-happyIn221 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap221 x)-{-# INLINE happyIn221 #-}-happyOut221 :: (HappyAbsSyn ) -> HappyWrap221-happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut221 #-}-newtype HappyWrap222 = HappyWrap222 (Located (HsSplice GhcPs))-happyIn222 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )-happyIn222 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap222 x)-{-# INLINE happyIn222 #-}-happyOut222 :: (HappyAbsSyn ) -> HappyWrap222-happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut222 #-}-newtype HappyWrap223 = HappyWrap223 ([LHsCmdTop GhcPs])-happyIn223 :: ([LHsCmdTop GhcPs]) -> (HappyAbsSyn )-happyIn223 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap223 x)-{-# INLINE happyIn223 #-}-happyOut223 :: (HappyAbsSyn ) -> HappyWrap223-happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut223 #-}-newtype HappyWrap224 = HappyWrap224 (LHsCmdTop GhcPs)-happyIn224 :: (LHsCmdTop GhcPs) -> (HappyAbsSyn )-happyIn224 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap224 x)-{-# INLINE happyIn224 #-}-happyOut224 :: (HappyAbsSyn ) -> HappyWrap224-happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut224 #-}-newtype HappyWrap225 = HappyWrap225 (([AddAnn],[LHsDecl GhcPs]))-happyIn225 :: (([AddAnn],[LHsDecl GhcPs])) -> (HappyAbsSyn )-happyIn225 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap225 x)-{-# INLINE happyIn225 #-}-happyOut225 :: (HappyAbsSyn ) -> HappyWrap225-happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut225 #-}-newtype HappyWrap226 = HappyWrap226 ([LHsDecl GhcPs])-happyIn226 :: ([LHsDecl GhcPs]) -> (HappyAbsSyn )-happyIn226 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap226 x)-{-# INLINE happyIn226 #-}-happyOut226 :: (HappyAbsSyn ) -> HappyWrap226-happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut226 #-}-newtype HappyWrap227 = HappyWrap227 (ECP)-happyIn227 :: (ECP) -> (HappyAbsSyn )-happyIn227 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap227 x)-{-# INLINE happyIn227 #-}-happyOut227 :: (HappyAbsSyn ) -> HappyWrap227-happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut227 #-}-newtype HappyWrap228 = HappyWrap228 (forall b. DisambECP b => PV ([AddAnn],SumOrTuple b))-happyIn228 :: (forall b. DisambECP b => PV ([AddAnn],SumOrTuple b)) -> (HappyAbsSyn )-happyIn228 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap228 x)-{-# INLINE happyIn228 #-}-happyOut228 :: (HappyAbsSyn ) -> HappyWrap228-happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut228 #-}-newtype HappyWrap229 = HappyWrap229 (forall b. DisambECP b => PV (SrcSpan,[Located (Maybe (Located b))]))-happyIn229 :: (forall b. DisambECP b => PV (SrcSpan,[Located (Maybe (Located b))])) -> (HappyAbsSyn )-happyIn229 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap229 x)-{-# INLINE happyIn229 #-}-happyOut229 :: (HappyAbsSyn ) -> HappyWrap229-happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut229 #-}-newtype HappyWrap230 = HappyWrap230 (forall b. DisambECP b => PV [Located (Maybe (Located b))])-happyIn230 :: (forall b. DisambECP b => PV [Located (Maybe (Located b))]) -> (HappyAbsSyn )-happyIn230 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap230 x)-{-# INLINE happyIn230 #-}-happyOut230 :: (HappyAbsSyn ) -> HappyWrap230-happyOut230 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut230 #-}-newtype HappyWrap231 = HappyWrap231 (forall b. DisambECP b => SrcSpan -> PV (Located b))-happyIn231 :: (forall b. DisambECP b => SrcSpan -> PV (Located b)) -> (HappyAbsSyn )-happyIn231 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap231 x)-{-# INLINE happyIn231 #-}-happyOut231 :: (HappyAbsSyn ) -> HappyWrap231-happyOut231 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut231 #-}-newtype HappyWrap232 = HappyWrap232 (forall b. DisambECP b => PV [Located b])-happyIn232 :: (forall b. DisambECP b => PV [Located b]) -> (HappyAbsSyn )-happyIn232 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap232 x)-{-# INLINE happyIn232 #-}-happyOut232 :: (HappyAbsSyn ) -> HappyWrap232-happyOut232 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut232 #-}-newtype HappyWrap233 = HappyWrap233 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn233 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn233 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap233 x)-{-# INLINE happyIn233 #-}-happyOut233 :: (HappyAbsSyn ) -> HappyWrap233-happyOut233 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut233 #-}-newtype HappyWrap234 = HappyWrap234 (Located [[LStmt GhcPs (LHsExpr GhcPs)]])-happyIn234 :: (Located [[LStmt GhcPs (LHsExpr GhcPs)]]) -> (HappyAbsSyn )-happyIn234 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap234 x)-{-# INLINE happyIn234 #-}-happyOut234 :: (HappyAbsSyn ) -> HappyWrap234-happyOut234 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut234 #-}-newtype HappyWrap235 = HappyWrap235 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn235 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn235 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap235 x)-{-# INLINE happyIn235 #-}-happyOut235 :: (HappyAbsSyn ) -> HappyWrap235-happyOut235 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut235 #-}-newtype HappyWrap236 = HappyWrap236 (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)))-happyIn236 :: (Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )-happyIn236 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap236 x)-{-# INLINE happyIn236 #-}-happyOut236 :: (HappyAbsSyn ) -> HappyWrap236-happyOut236 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut236 #-}-newtype HappyWrap237 = HappyWrap237 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn237 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn237 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap237 x)-{-# INLINE happyIn237 #-}-happyOut237 :: (HappyAbsSyn ) -> HappyWrap237-happyOut237 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut237 #-}-newtype HappyWrap238 = HappyWrap238 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn238 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn238 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap238 x)-{-# INLINE happyIn238 #-}-happyOut238 :: (HappyAbsSyn ) -> HappyWrap238-happyOut238 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut238 #-}-newtype HappyWrap239 = HappyWrap239 (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])))-happyIn239 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)]))) -> (HappyAbsSyn )-happyIn239 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap239 x)-{-# INLINE happyIn239 #-}-happyOut239 :: (HappyAbsSyn ) -> HappyWrap239-happyOut239 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut239 #-}-newtype HappyWrap240 = HappyWrap240 (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])))-happyIn240 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)]))) -> (HappyAbsSyn )-happyIn240 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap240 x)-{-# INLINE happyIn240 #-}-happyOut240 :: (HappyAbsSyn ) -> HappyWrap240-happyOut240 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut240 #-}-newtype HappyWrap241 = HappyWrap241 (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)])))-happyIn241 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LMatch GhcPs (Located b)]))) -> (HappyAbsSyn )-happyIn241 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap241 x)-{-# INLINE happyIn241 #-}-happyOut241 :: (HappyAbsSyn ) -> HappyWrap241-happyOut241 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut241 #-}-newtype HappyWrap242 = HappyWrap242 (forall b. DisambECP b => PV (LMatch GhcPs (Located b)))-happyIn242 :: (forall b. DisambECP b => PV (LMatch GhcPs (Located b))) -> (HappyAbsSyn )-happyIn242 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap242 x)-{-# INLINE happyIn242 #-}-happyOut242 :: (HappyAbsSyn ) -> HappyWrap242-happyOut242 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut242 #-}-newtype HappyWrap243 = HappyWrap243 (forall b. DisambECP b => PV (Located ([AddAnn],GRHSs GhcPs (Located b))))-happyIn243 :: (forall b. DisambECP b => PV (Located ([AddAnn],GRHSs GhcPs (Located b)))) -> (HappyAbsSyn )-happyIn243 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap243 x)-{-# INLINE happyIn243 #-}-happyOut243 :: (HappyAbsSyn ) -> HappyWrap243-happyOut243 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut243 #-}-newtype HappyWrap244 = HappyWrap244 (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)]))-happyIn244 :: (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)])) -> (HappyAbsSyn )-happyIn244 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap244 x)-{-# INLINE happyIn244 #-}-happyOut244 :: (HappyAbsSyn ) -> HappyWrap244-happyOut244 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut244 #-}-newtype HappyWrap245 = HappyWrap245 (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)]))-happyIn245 :: (forall b. DisambECP b => PV (Located [LGRHS GhcPs (Located b)])) -> (HappyAbsSyn )-happyIn245 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap245 x)-{-# INLINE happyIn245 #-}-happyOut245 :: (HappyAbsSyn ) -> HappyWrap245-happyOut245 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut245 #-}-newtype HappyWrap246 = HappyWrap246 (Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)]))-happyIn246 :: (Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )-happyIn246 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap246 x)-{-# INLINE happyIn246 #-}-happyOut246 :: (HappyAbsSyn ) -> HappyWrap246-happyOut246 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut246 #-}-newtype HappyWrap247 = HappyWrap247 (forall b. DisambECP b => PV (LGRHS GhcPs (Located b)))-happyIn247 :: (forall b. DisambECP b => PV (LGRHS GhcPs (Located b))) -> (HappyAbsSyn )-happyIn247 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap247 x)-{-# INLINE happyIn247 #-}-happyOut247 :: (HappyAbsSyn ) -> HappyWrap247-happyOut247 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut247 #-}-newtype HappyWrap248 = HappyWrap248 (LPat GhcPs)-happyIn248 :: (LPat GhcPs) -> (HappyAbsSyn )-happyIn248 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap248 x)-{-# INLINE happyIn248 #-}-happyOut248 :: (HappyAbsSyn ) -> HappyWrap248-happyOut248 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut248 #-}-newtype HappyWrap249 = HappyWrap249 (LPat GhcPs)-happyIn249 :: (LPat GhcPs) -> (HappyAbsSyn )-happyIn249 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap249 x)-{-# INLINE happyIn249 #-}-happyOut249 :: (HappyAbsSyn ) -> HappyWrap249-happyOut249 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut249 #-}-newtype HappyWrap250 = HappyWrap250 (LPat GhcPs)-happyIn250 :: (LPat GhcPs) -> (HappyAbsSyn )-happyIn250 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap250 x)-{-# INLINE happyIn250 #-}-happyOut250 :: (HappyAbsSyn ) -> HappyWrap250-happyOut250 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut250 #-}-newtype HappyWrap251 = HappyWrap251 ([LPat GhcPs])-happyIn251 :: ([LPat GhcPs]) -> (HappyAbsSyn )-happyIn251 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap251 x)-{-# INLINE happyIn251 #-}-happyOut251 :: (HappyAbsSyn ) -> HappyWrap251-happyOut251 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut251 #-}-newtype HappyWrap252 = HappyWrap252 (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)])))-happyIn252 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)]))) -> (HappyAbsSyn )-happyIn252 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap252 x)-{-# INLINE happyIn252 #-}-happyOut252 :: (HappyAbsSyn ) -> HappyWrap252-happyOut252 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut252 #-}-newtype HappyWrap253 = HappyWrap253 (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)])))-happyIn253 :: (forall b. DisambECP b => PV (Located ([AddAnn],[LStmt GhcPs (Located b)]))) -> (HappyAbsSyn )-happyIn253 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap253 x)-{-# INLINE happyIn253 #-}-happyOut253 :: (HappyAbsSyn ) -> HappyWrap253-happyOut253 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut253 #-}-newtype HappyWrap254 = HappyWrap254 (Maybe (LStmt GhcPs (LHsExpr GhcPs)))-happyIn254 :: (Maybe (LStmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )-happyIn254 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap254 x)-{-# INLINE happyIn254 #-}-happyOut254 :: (HappyAbsSyn ) -> HappyWrap254-happyOut254 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut254 #-}-newtype HappyWrap255 = HappyWrap255 (LStmt GhcPs (LHsExpr GhcPs))-happyIn255 :: (LStmt GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )-happyIn255 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap255 x)-{-# INLINE happyIn255 #-}-happyOut255 :: (HappyAbsSyn ) -> HappyWrap255-happyOut255 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut255 #-}-newtype HappyWrap256 = HappyWrap256 (forall b. DisambECP b => PV (LStmt GhcPs (Located b)))-happyIn256 :: (forall b. DisambECP b => PV (LStmt GhcPs (Located b))) -> (HappyAbsSyn )-happyIn256 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap256 x)-{-# INLINE happyIn256 #-}-happyOut256 :: (HappyAbsSyn ) -> HappyWrap256-happyOut256 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut256 #-}-newtype HappyWrap257 = HappyWrap257 (forall b. DisambECP b => PV (LStmt GhcPs (Located b)))-happyIn257 :: (forall b. DisambECP b => PV (LStmt GhcPs (Located b))) -> (HappyAbsSyn )-happyIn257 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap257 x)-{-# INLINE happyIn257 #-}-happyOut257 :: (HappyAbsSyn ) -> HappyWrap257-happyOut257 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut257 #-}-newtype HappyWrap258 = HappyWrap258 (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan)))-happyIn258 :: (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan))) -> (HappyAbsSyn )-happyIn258 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap258 x)-{-# INLINE happyIn258 #-}-happyOut258 :: (HappyAbsSyn ) -> HappyWrap258-happyOut258 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut258 #-}-newtype HappyWrap259 = HappyWrap259 (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan)))-happyIn259 :: (forall b. DisambECP b => PV ([AddAnn],([LHsRecField GhcPs (Located b)], Maybe SrcSpan))) -> (HappyAbsSyn )-happyIn259 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap259 x)-{-# INLINE happyIn259 #-}-happyOut259 :: (HappyAbsSyn ) -> HappyWrap259-happyOut259 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut259 #-}-newtype HappyWrap260 = HappyWrap260 (forall b. DisambECP b => PV (LHsRecField GhcPs (Located b)))-happyIn260 :: (forall b. DisambECP b => PV (LHsRecField GhcPs (Located b))) -> (HappyAbsSyn )-happyIn260 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap260 x)-{-# INLINE happyIn260 #-}-happyOut260 :: (HappyAbsSyn ) -> HappyWrap260-happyOut260 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut260 #-}-newtype HappyWrap261 = HappyWrap261 (Located [LIPBind GhcPs])-happyIn261 :: (Located [LIPBind GhcPs]) -> (HappyAbsSyn )-happyIn261 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap261 x)-{-# INLINE happyIn261 #-}-happyOut261 :: (HappyAbsSyn ) -> HappyWrap261-happyOut261 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut261 #-}-newtype HappyWrap262 = HappyWrap262 (LIPBind GhcPs)-happyIn262 :: (LIPBind GhcPs) -> (HappyAbsSyn )-happyIn262 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap262 x)-{-# INLINE happyIn262 #-}-happyOut262 :: (HappyAbsSyn ) -> HappyWrap262-happyOut262 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut262 #-}-newtype HappyWrap263 = HappyWrap263 (Located HsIPName)-happyIn263 :: (Located HsIPName) -> (HappyAbsSyn )-happyIn263 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap263 x)-{-# INLINE happyIn263 #-}-happyOut263 :: (HappyAbsSyn ) -> HappyWrap263-happyOut263 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut263 #-}-newtype HappyWrap264 = HappyWrap264 (Located FastString)-happyIn264 :: (Located FastString) -> (HappyAbsSyn )-happyIn264 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap264 x)-{-# INLINE happyIn264 #-}-happyOut264 :: (HappyAbsSyn ) -> HappyWrap264-happyOut264 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut264 #-}-newtype HappyWrap265 = HappyWrap265 (LBooleanFormula (Located RdrName))-happyIn265 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn265 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap265 x)-{-# INLINE happyIn265 #-}-happyOut265 :: (HappyAbsSyn ) -> HappyWrap265-happyOut265 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut265 #-}-newtype HappyWrap266 = HappyWrap266 (LBooleanFormula (Located RdrName))-happyIn266 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn266 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap266 x)-{-# INLINE happyIn266 #-}-happyOut266 :: (HappyAbsSyn ) -> HappyWrap266-happyOut266 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut266 #-}-newtype HappyWrap267 = HappyWrap267 (LBooleanFormula (Located RdrName))-happyIn267 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn267 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap267 x)-{-# INLINE happyIn267 #-}-happyOut267 :: (HappyAbsSyn ) -> HappyWrap267-happyOut267 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut267 #-}-newtype HappyWrap268 = HappyWrap268 ([LBooleanFormula (Located RdrName)])-happyIn268 :: ([LBooleanFormula (Located RdrName)]) -> (HappyAbsSyn )-happyIn268 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap268 x)-{-# INLINE happyIn268 #-}-happyOut268 :: (HappyAbsSyn ) -> HappyWrap268-happyOut268 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut268 #-}-newtype HappyWrap269 = HappyWrap269 (LBooleanFormula (Located RdrName))-happyIn269 :: (LBooleanFormula (Located RdrName)) -> (HappyAbsSyn )-happyIn269 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap269 x)-{-# INLINE happyIn269 #-}-happyOut269 :: (HappyAbsSyn ) -> HappyWrap269-happyOut269 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut269 #-}-newtype HappyWrap270 = HappyWrap270 (Located [Located RdrName])-happyIn270 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn270 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap270 x)-{-# INLINE happyIn270 #-}-happyOut270 :: (HappyAbsSyn ) -> HappyWrap270-happyOut270 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut270 #-}-newtype HappyWrap271 = HappyWrap271 (Located RdrName)-happyIn271 :: (Located RdrName) -> (HappyAbsSyn )-happyIn271 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap271 x)-{-# INLINE happyIn271 #-}-happyOut271 :: (HappyAbsSyn ) -> HappyWrap271-happyOut271 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut271 #-}-newtype HappyWrap272 = HappyWrap272 (Located RdrName)-happyIn272 :: (Located RdrName) -> (HappyAbsSyn )-happyIn272 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap272 x)-{-# INLINE happyIn272 #-}-happyOut272 :: (HappyAbsSyn ) -> HappyWrap272-happyOut272 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut272 #-}-newtype HappyWrap273 = HappyWrap273 (Located RdrName)-happyIn273 :: (Located RdrName) -> (HappyAbsSyn )-happyIn273 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap273 x)-{-# INLINE happyIn273 #-}-happyOut273 :: (HappyAbsSyn ) -> HappyWrap273-happyOut273 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut273 #-}-newtype HappyWrap274 = HappyWrap274 (Located RdrName)-happyIn274 :: (Located RdrName) -> (HappyAbsSyn )-happyIn274 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap274 x)-{-# INLINE happyIn274 #-}-happyOut274 :: (HappyAbsSyn ) -> HappyWrap274-happyOut274 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut274 #-}-newtype HappyWrap275 = HappyWrap275 (Located RdrName)-happyIn275 :: (Located RdrName) -> (HappyAbsSyn )-happyIn275 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap275 x)-{-# INLINE happyIn275 #-}-happyOut275 :: (HappyAbsSyn ) -> HappyWrap275-happyOut275 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut275 #-}-newtype HappyWrap276 = HappyWrap276 (Located [Located RdrName])-happyIn276 :: (Located [Located RdrName]) -> (HappyAbsSyn )-happyIn276 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap276 x)-{-# INLINE happyIn276 #-}-happyOut276 :: (HappyAbsSyn ) -> HappyWrap276-happyOut276 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut276 #-}-newtype HappyWrap277 = HappyWrap277 (Located DataCon)-happyIn277 :: (Located DataCon) -> (HappyAbsSyn )-happyIn277 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap277 x)-{-# INLINE happyIn277 #-}-happyOut277 :: (HappyAbsSyn ) -> HappyWrap277-happyOut277 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut277 #-}-newtype HappyWrap278 = HappyWrap278 (Located DataCon)-happyIn278 :: (Located DataCon) -> (HappyAbsSyn )-happyIn278 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap278 x)-{-# INLINE happyIn278 #-}-happyOut278 :: (HappyAbsSyn ) -> HappyWrap278-happyOut278 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut278 #-}-newtype HappyWrap279 = HappyWrap279 (Located RdrName)-happyIn279 :: (Located RdrName) -> (HappyAbsSyn )-happyIn279 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap279 x)-{-# INLINE happyIn279 #-}-happyOut279 :: (HappyAbsSyn ) -> HappyWrap279-happyOut279 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut279 #-}-newtype HappyWrap280 = HappyWrap280 (Located RdrName)-happyIn280 :: (Located RdrName) -> (HappyAbsSyn )-happyIn280 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap280 x)-{-# INLINE happyIn280 #-}-happyOut280 :: (HappyAbsSyn ) -> HappyWrap280-happyOut280 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut280 #-}-newtype HappyWrap281 = HappyWrap281 (Located RdrName)-happyIn281 :: (Located RdrName) -> (HappyAbsSyn )-happyIn281 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap281 x)-{-# INLINE happyIn281 #-}-happyOut281 :: (HappyAbsSyn ) -> HappyWrap281-happyOut281 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut281 #-}-newtype HappyWrap282 = HappyWrap282 (Located RdrName)-happyIn282 :: (Located RdrName) -> (HappyAbsSyn )-happyIn282 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap282 x)-{-# INLINE happyIn282 #-}-happyOut282 :: (HappyAbsSyn ) -> HappyWrap282-happyOut282 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut282 #-}-newtype HappyWrap283 = HappyWrap283 (Located RdrName)-happyIn283 :: (Located RdrName) -> (HappyAbsSyn )-happyIn283 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap283 x)-{-# INLINE happyIn283 #-}-happyOut283 :: (HappyAbsSyn ) -> HappyWrap283-happyOut283 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut283 #-}-newtype HappyWrap284 = HappyWrap284 (Located RdrName)-happyIn284 :: (Located RdrName) -> (HappyAbsSyn )-happyIn284 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap284 x)-{-# INLINE happyIn284 #-}-happyOut284 :: (HappyAbsSyn ) -> HappyWrap284-happyOut284 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut284 #-}-newtype HappyWrap285 = HappyWrap285 (Located RdrName)-happyIn285 :: (Located RdrName) -> (HappyAbsSyn )-happyIn285 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap285 x)-{-# INLINE happyIn285 #-}-happyOut285 :: (HappyAbsSyn ) -> HappyWrap285-happyOut285 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut285 #-}-newtype HappyWrap286 = HappyWrap286 (Located RdrName)-happyIn286 :: (Located RdrName) -> (HappyAbsSyn )-happyIn286 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap286 x)-{-# INLINE happyIn286 #-}-happyOut286 :: (HappyAbsSyn ) -> HappyWrap286-happyOut286 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut286 #-}-newtype HappyWrap287 = HappyWrap287 (LHsType GhcPs)-happyIn287 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn287 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap287 x)-{-# INLINE happyIn287 #-}-happyOut287 :: (HappyAbsSyn ) -> HappyWrap287-happyOut287 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut287 #-}-newtype HappyWrap288 = HappyWrap288 (Located RdrName)-happyIn288 :: (Located RdrName) -> (HappyAbsSyn )-happyIn288 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap288 x)-{-# INLINE happyIn288 #-}-happyOut288 :: (HappyAbsSyn ) -> HappyWrap288-happyOut288 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut288 #-}-newtype HappyWrap289 = HappyWrap289 (Located RdrName)-happyIn289 :: (Located RdrName) -> (HappyAbsSyn )-happyIn289 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap289 x)-{-# INLINE happyIn289 #-}-happyOut289 :: (HappyAbsSyn ) -> HappyWrap289-happyOut289 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut289 #-}-newtype HappyWrap290 = HappyWrap290 (Located RdrName)-happyIn290 :: (Located RdrName) -> (HappyAbsSyn )-happyIn290 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap290 x)-{-# INLINE happyIn290 #-}-happyOut290 :: (HappyAbsSyn ) -> HappyWrap290-happyOut290 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut290 #-}-newtype HappyWrap291 = HappyWrap291 (Located RdrName)-happyIn291 :: (Located RdrName) -> (HappyAbsSyn )-happyIn291 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap291 x)-{-# INLINE happyIn291 #-}-happyOut291 :: (HappyAbsSyn ) -> HappyWrap291-happyOut291 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut291 #-}-newtype HappyWrap292 = HappyWrap292 (Located RdrName)-happyIn292 :: (Located RdrName) -> (HappyAbsSyn )-happyIn292 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap292 x)-{-# INLINE happyIn292 #-}-happyOut292 :: (HappyAbsSyn ) -> HappyWrap292-happyOut292 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut292 #-}-newtype HappyWrap293 = HappyWrap293 (forall b. DisambInfixOp b => PV (Located b))-happyIn293 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )-happyIn293 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap293 x)-{-# INLINE happyIn293 #-}-happyOut293 :: (HappyAbsSyn ) -> HappyWrap293-happyOut293 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut293 #-}-newtype HappyWrap294 = HappyWrap294 (forall b. DisambInfixOp b => PV (Located b))-happyIn294 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )-happyIn294 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap294 x)-{-# INLINE happyIn294 #-}-happyOut294 :: (HappyAbsSyn ) -> HappyWrap294-happyOut294 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut294 #-}-newtype HappyWrap295 = HappyWrap295 (forall b. DisambInfixOp b => PV (Located b))-happyIn295 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )-happyIn295 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap295 x)-{-# INLINE happyIn295 #-}-happyOut295 :: (HappyAbsSyn ) -> HappyWrap295-happyOut295 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut295 #-}-newtype HappyWrap296 = HappyWrap296 (Located RdrName)-happyIn296 :: (Located RdrName) -> (HappyAbsSyn )-happyIn296 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap296 x)-{-# INLINE happyIn296 #-}-happyOut296 :: (HappyAbsSyn ) -> HappyWrap296-happyOut296 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut296 #-}-newtype HappyWrap297 = HappyWrap297 (Located RdrName)-happyIn297 :: (Located RdrName) -> (HappyAbsSyn )-happyIn297 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap297 x)-{-# INLINE happyIn297 #-}-happyOut297 :: (HappyAbsSyn ) -> HappyWrap297-happyOut297 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut297 #-}-newtype HappyWrap298 = HappyWrap298 (Located RdrName)-happyIn298 :: (Located RdrName) -> (HappyAbsSyn )-happyIn298 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap298 x)-{-# INLINE happyIn298 #-}-happyOut298 :: (HappyAbsSyn ) -> HappyWrap298-happyOut298 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut298 #-}-newtype HappyWrap299 = HappyWrap299 (Located RdrName)-happyIn299 :: (Located RdrName) -> (HappyAbsSyn )-happyIn299 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap299 x)-{-# INLINE happyIn299 #-}-happyOut299 :: (HappyAbsSyn ) -> HappyWrap299-happyOut299 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut299 #-}-newtype HappyWrap300 = HappyWrap300 (Located RdrName)-happyIn300 :: (Located RdrName) -> (HappyAbsSyn )-happyIn300 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap300 x)-{-# INLINE happyIn300 #-}-happyOut300 :: (HappyAbsSyn ) -> HappyWrap300-happyOut300 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut300 #-}-newtype HappyWrap301 = HappyWrap301 (Located RdrName)-happyIn301 :: (Located RdrName) -> (HappyAbsSyn )-happyIn301 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap301 x)-{-# INLINE happyIn301 #-}-happyOut301 :: (HappyAbsSyn ) -> HappyWrap301-happyOut301 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut301 #-}-newtype HappyWrap302 = HappyWrap302 (Located RdrName)-happyIn302 :: (Located RdrName) -> (HappyAbsSyn )-happyIn302 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap302 x)-{-# INLINE happyIn302 #-}-happyOut302 :: (HappyAbsSyn ) -> HappyWrap302-happyOut302 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut302 #-}-newtype HappyWrap303 = HappyWrap303 (Located RdrName)-happyIn303 :: (Located RdrName) -> (HappyAbsSyn )-happyIn303 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap303 x)-{-# INLINE happyIn303 #-}-happyOut303 :: (HappyAbsSyn ) -> HappyWrap303-happyOut303 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut303 #-}-newtype HappyWrap304 = HappyWrap304 (Located RdrName)-happyIn304 :: (Located RdrName) -> (HappyAbsSyn )-happyIn304 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap304 x)-{-# INLINE happyIn304 #-}-happyOut304 :: (HappyAbsSyn ) -> HappyWrap304-happyOut304 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut304 #-}-newtype HappyWrap305 = HappyWrap305 (Located RdrName)-happyIn305 :: (Located RdrName) -> (HappyAbsSyn )-happyIn305 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap305 x)-{-# INLINE happyIn305 #-}-happyOut305 :: (HappyAbsSyn ) -> HappyWrap305-happyOut305 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut305 #-}-newtype HappyWrap306 = HappyWrap306 (Located RdrName)-happyIn306 :: (Located RdrName) -> (HappyAbsSyn )-happyIn306 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap306 x)-{-# INLINE happyIn306 #-}-happyOut306 :: (HappyAbsSyn ) -> HappyWrap306-happyOut306 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut306 #-}-newtype HappyWrap307 = HappyWrap307 (Located RdrName)-happyIn307 :: (Located RdrName) -> (HappyAbsSyn )-happyIn307 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap307 x)-{-# INLINE happyIn307 #-}-happyOut307 :: (HappyAbsSyn ) -> HappyWrap307-happyOut307 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut307 #-}-newtype HappyWrap308 = HappyWrap308 (Located RdrName)-happyIn308 :: (Located RdrName) -> (HappyAbsSyn )-happyIn308 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap308 x)-{-# INLINE happyIn308 #-}-happyOut308 :: (HappyAbsSyn ) -> HappyWrap308-happyOut308 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut308 #-}-newtype HappyWrap309 = HappyWrap309 (Located RdrName)-happyIn309 :: (Located RdrName) -> (HappyAbsSyn )-happyIn309 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap309 x)-{-# INLINE happyIn309 #-}-happyOut309 :: (HappyAbsSyn ) -> HappyWrap309-happyOut309 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut309 #-}-newtype HappyWrap310 = HappyWrap310 (Located FastString)-happyIn310 :: (Located FastString) -> (HappyAbsSyn )-happyIn310 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap310 x)-{-# INLINE happyIn310 #-}-happyOut310 :: (HappyAbsSyn ) -> HappyWrap310-happyOut310 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut310 #-}-newtype HappyWrap311 = HappyWrap311 (Located FastString)-happyIn311 :: (Located FastString) -> (HappyAbsSyn )-happyIn311 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap311 x)-{-# INLINE happyIn311 #-}-happyOut311 :: (HappyAbsSyn ) -> HappyWrap311-happyOut311 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut311 #-}-newtype HappyWrap312 = HappyWrap312 (Located RdrName)-happyIn312 :: (Located RdrName) -> (HappyAbsSyn )-happyIn312 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap312 x)-{-# INLINE happyIn312 #-}-happyOut312 :: (HappyAbsSyn ) -> HappyWrap312-happyOut312 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut312 #-}-newtype HappyWrap313 = HappyWrap313 (Located RdrName)-happyIn313 :: (Located RdrName) -> (HappyAbsSyn )-happyIn313 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap313 x)-{-# INLINE happyIn313 #-}-happyOut313 :: (HappyAbsSyn ) -> HappyWrap313-happyOut313 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut313 #-}-newtype HappyWrap314 = HappyWrap314 (Located RdrName)-happyIn314 :: (Located RdrName) -> (HappyAbsSyn )-happyIn314 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap314 x)-{-# INLINE happyIn314 #-}-happyOut314 :: (HappyAbsSyn ) -> HappyWrap314-happyOut314 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut314 #-}-newtype HappyWrap315 = HappyWrap315 (Located RdrName)-happyIn315 :: (Located RdrName) -> (HappyAbsSyn )-happyIn315 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap315 x)-{-# INLINE happyIn315 #-}-happyOut315 :: (HappyAbsSyn ) -> HappyWrap315-happyOut315 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut315 #-}-newtype HappyWrap316 = HappyWrap316 (Located (HsLit GhcPs))-happyIn316 :: (Located (HsLit GhcPs)) -> (HappyAbsSyn )-happyIn316 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap316 x)-{-# INLINE happyIn316 #-}-happyOut316 :: (HappyAbsSyn ) -> HappyWrap316-happyOut316 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut316 #-}-newtype HappyWrap317 = HappyWrap317 (())-happyIn317 :: (()) -> (HappyAbsSyn )-happyIn317 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap317 x)-{-# INLINE happyIn317 #-}-happyOut317 :: (HappyAbsSyn ) -> HappyWrap317-happyOut317 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut317 #-}-newtype HappyWrap318 = HappyWrap318 (Located ModuleName)-happyIn318 :: (Located ModuleName) -> (HappyAbsSyn )-happyIn318 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap318 x)-{-# INLINE happyIn318 #-}-happyOut318 :: (HappyAbsSyn ) -> HappyWrap318-happyOut318 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut318 #-}-newtype HappyWrap319 = HappyWrap319 (([SrcSpan],Int))-happyIn319 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn319 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap319 x)-{-# INLINE happyIn319 #-}-happyOut319 :: (HappyAbsSyn ) -> HappyWrap319-happyOut319 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut319 #-}-newtype HappyWrap320 = HappyWrap320 (([SrcSpan],Int))-happyIn320 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn320 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap320 x)-{-# INLINE happyIn320 #-}-happyOut320 :: (HappyAbsSyn ) -> HappyWrap320-happyOut320 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut320 #-}-newtype HappyWrap321 = HappyWrap321 (([SrcSpan],Int))-happyIn321 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn321 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap321 x)-{-# INLINE happyIn321 #-}-happyOut321 :: (HappyAbsSyn ) -> HappyWrap321-happyOut321 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut321 #-}-newtype HappyWrap322 = HappyWrap322 (LHsDocString)-happyIn322 :: (LHsDocString) -> (HappyAbsSyn )-happyIn322 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap322 x)-{-# INLINE happyIn322 #-}-happyOut322 :: (HappyAbsSyn ) -> HappyWrap322-happyOut322 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut322 #-}-newtype HappyWrap323 = HappyWrap323 (LHsDocString)-happyIn323 :: (LHsDocString) -> (HappyAbsSyn )-happyIn323 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap323 x)-{-# INLINE happyIn323 #-}-happyOut323 :: (HappyAbsSyn ) -> HappyWrap323-happyOut323 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut323 #-}-newtype HappyWrap324 = HappyWrap324 (Located (String, HsDocString))-happyIn324 :: (Located (String, HsDocString)) -> (HappyAbsSyn )-happyIn324 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap324 x)-{-# INLINE happyIn324 #-}-happyOut324 :: (HappyAbsSyn ) -> HappyWrap324-happyOut324 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut324 #-}-newtype HappyWrap325 = HappyWrap325 (Located (Int, HsDocString))-happyIn325 :: (Located (Int, HsDocString)) -> (HappyAbsSyn )-happyIn325 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap325 x)-{-# INLINE happyIn325 #-}-happyOut325 :: (HappyAbsSyn ) -> HappyWrap325-happyOut325 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut325 #-}-newtype HappyWrap326 = HappyWrap326 (Maybe LHsDocString)-happyIn326 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn326 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap326 x)-{-# INLINE happyIn326 #-}-happyOut326 :: (HappyAbsSyn ) -> HappyWrap326-happyOut326 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut326 #-}-newtype HappyWrap327 = HappyWrap327 (Maybe LHsDocString)-happyIn327 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn327 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap327 x)-{-# INLINE happyIn327 #-}-happyOut327 :: (HappyAbsSyn ) -> HappyWrap327-happyOut327 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut327 #-}-newtype HappyWrap328 = HappyWrap328 (Maybe LHsDocString)-happyIn328 :: (Maybe LHsDocString) -> (HappyAbsSyn )-happyIn328 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap328 x)-{-# INLINE happyIn328 #-}-happyOut328 :: (HappyAbsSyn ) -> HappyWrap328-happyOut328 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut328 #-}-newtype HappyWrap329 = HappyWrap329 (ECP)-happyIn329 :: (ECP) -> (HappyAbsSyn )-happyIn329 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap329 x)-{-# INLINE happyIn329 #-}-happyOut329 :: (HappyAbsSyn ) -> HappyWrap329-happyOut329 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut329 #-}-newtype HappyWrap330 = HappyWrap330 (ECP)-happyIn330 :: (ECP) -> (HappyAbsSyn )-happyIn330 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap330 x)-{-# INLINE happyIn330 #-}-happyOut330 :: (HappyAbsSyn ) -> HappyWrap330-happyOut330 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut330 #-}-happyInTok :: ((Located Token)) -> (HappyAbsSyn )-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn ) -> ((Located Token))-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyExpList :: HappyAddr-happyExpList = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 * 479-        bit_end = (st + 1) * 479-        read_bit = readArrayBit happyExpList-        bits = map read_bit [bit_start..bit_end - 1]-        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# "\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\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--happyDefActions :: HappyAddr-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\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\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),-	(14 , happyReduce_14),-	(15 , happyReduce_15),-	(16 , happyReduce_16),-	(17 , happyReduce_17),-	(18 , happyReduce_18),-	(19 , happyReduce_19),-	(20 , happyReduce_20),-	(21 , happyReduce_21),-	(22 , happyReduce_22),-	(23 , happyReduce_23),-	(24 , happyReduce_24),-	(25 , happyReduce_25),-	(26 , happyReduce_26),-	(27 , happyReduce_27),-	(28 , happyReduce_28),-	(29 , happyReduce_29),-	(30 , happyReduce_30),-	(31 , happyReduce_31),-	(32 , happyReduce_32),-	(33 , happyReduce_33),-	(34 , happyReduce_34),-	(35 , happyReduce_35),-	(36 , happyReduce_36),-	(37 , happyReduce_37),-	(38 , happyReduce_38),-	(39 , happyReduce_39),-	(40 , happyReduce_40),-	(41 , happyReduce_41),-	(42 , happyReduce_42),-	(43 , happyReduce_43),-	(44 , happyReduce_44),-	(45 , happyReduce_45),-	(46 , happyReduce_46),-	(47 , happyReduce_47),-	(48 , happyReduce_48),-	(49 , happyReduce_49),-	(50 , happyReduce_50),-	(51 , happyReduce_51),-	(52 , happyReduce_52),-	(53 , happyReduce_53),-	(54 , happyReduce_54),-	(55 , happyReduce_55),-	(56 , happyReduce_56),-	(57 , happyReduce_57),-	(58 , happyReduce_58),-	(59 , happyReduce_59),-	(60 , happyReduce_60),-	(61 , happyReduce_61),-	(62 , happyReduce_62),-	(63 , happyReduce_63),-	(64 , happyReduce_64),-	(65 , happyReduce_65),-	(66 , happyReduce_66),-	(67 , happyReduce_67),-	(68 , happyReduce_68),-	(69 , happyReduce_69),-	(70 , happyReduce_70),-	(71 , happyReduce_71),-	(72 , happyReduce_72),-	(73 , happyReduce_73),-	(74 , happyReduce_74),-	(75 , happyReduce_75),-	(76 , happyReduce_76),-	(77 , happyReduce_77),-	(78 , happyReduce_78),-	(79 , happyReduce_79),-	(80 , happyReduce_80),-	(81 , happyReduce_81),-	(82 , happyReduce_82),-	(83 , happyReduce_83),-	(84 , happyReduce_84),-	(85 , happyReduce_85),-	(86 , happyReduce_86),-	(87 , happyReduce_87),-	(88 , happyReduce_88),-	(89 , happyReduce_89),-	(90 , happyReduce_90),-	(91 , happyReduce_91),-	(92 , happyReduce_92),-	(93 , happyReduce_93),-	(94 , happyReduce_94),-	(95 , happyReduce_95),-	(96 , happyReduce_96),-	(97 , happyReduce_97),-	(98 , happyReduce_98),-	(99 , happyReduce_99),-	(100 , happyReduce_100),-	(101 , happyReduce_101),-	(102 , happyReduce_102),-	(103 , happyReduce_103),-	(104 , happyReduce_104),-	(105 , happyReduce_105),-	(106 , happyReduce_106),-	(107 , happyReduce_107),-	(108 , happyReduce_108),-	(109 , happyReduce_109),-	(110 , happyReduce_110),-	(111 , happyReduce_111),-	(112 , happyReduce_112),-	(113 , happyReduce_113),-	(114 , happyReduce_114),-	(115 , happyReduce_115),-	(116 , happyReduce_116),-	(117 , happyReduce_117),-	(118 , happyReduce_118),-	(119 , happyReduce_119),-	(120 , happyReduce_120),-	(121 , happyReduce_121),-	(122 , happyReduce_122),-	(123 , happyReduce_123),-	(124 , happyReduce_124),-	(125 , happyReduce_125),-	(126 , happyReduce_126),-	(127 , happyReduce_127),-	(128 , happyReduce_128),-	(129 , happyReduce_129),-	(130 , happyReduce_130),-	(131 , happyReduce_131),-	(132 , happyReduce_132),-	(133 , happyReduce_133),-	(134 , happyReduce_134),-	(135 , happyReduce_135),-	(136 , happyReduce_136),-	(137 , happyReduce_137),-	(138 , happyReduce_138),-	(139 , happyReduce_139),-	(140 , happyReduce_140),-	(141 , happyReduce_141),-	(142 , happyReduce_142),-	(143 , happyReduce_143),-	(144 , happyReduce_144),-	(145 , happyReduce_145),-	(146 , happyReduce_146),-	(147 , happyReduce_147),-	(148 , happyReduce_148),-	(149 , happyReduce_149),-	(150 , happyReduce_150),-	(151 , happyReduce_151),-	(152 , happyReduce_152),-	(153 , happyReduce_153),-	(154 , happyReduce_154),-	(155 , happyReduce_155),-	(156 , happyReduce_156),-	(157 , happyReduce_157),-	(158 , happyReduce_158),-	(159 , happyReduce_159),-	(160 , happyReduce_160),-	(161 , happyReduce_161),-	(162 , happyReduce_162),-	(163 , happyReduce_163),-	(164 , happyReduce_164),-	(165 , happyReduce_165),-	(166 , happyReduce_166),-	(167 , happyReduce_167),-	(168 , happyReduce_168),-	(169 , happyReduce_169),-	(170 , happyReduce_170),-	(171 , happyReduce_171),-	(172 , happyReduce_172),-	(173 , happyReduce_173),-	(174 , happyReduce_174),-	(175 , happyReduce_175),-	(176 , happyReduce_176),-	(177 , happyReduce_177),-	(178 , happyReduce_178),-	(179 , happyReduce_179),-	(180 , happyReduce_180),-	(181 , happyReduce_181),-	(182 , happyReduce_182),-	(183 , happyReduce_183),-	(184 , happyReduce_184),-	(185 , happyReduce_185),-	(186 , happyReduce_186),-	(187 , happyReduce_187),-	(188 , happyReduce_188),-	(189 , happyReduce_189),-	(190 , happyReduce_190),-	(191 , happyReduce_191),-	(192 , happyReduce_192),-	(193 , happyReduce_193),-	(194 , happyReduce_194),-	(195 , happyReduce_195),-	(196 , happyReduce_196),-	(197 , happyReduce_197),-	(198 , happyReduce_198),-	(199 , happyReduce_199),-	(200 , happyReduce_200),-	(201 , happyReduce_201),-	(202 , happyReduce_202),-	(203 , happyReduce_203),-	(204 , happyReduce_204),-	(205 , happyReduce_205),-	(206 , happyReduce_206),-	(207 , happyReduce_207),-	(208 , happyReduce_208),-	(209 , happyReduce_209),-	(210 , happyReduce_210),-	(211 , happyReduce_211),-	(212 , happyReduce_212),-	(213 , happyReduce_213),-	(214 , happyReduce_214),-	(215 , happyReduce_215),-	(216 , happyReduce_216),-	(217 , happyReduce_217),-	(218 , happyReduce_218),-	(219 , happyReduce_219),-	(220 , happyReduce_220),-	(221 , happyReduce_221),-	(222 , happyReduce_222),-	(223 , happyReduce_223),-	(224 , happyReduce_224),-	(225 , happyReduce_225),-	(226 , happyReduce_226),-	(227 , happyReduce_227),-	(228 , happyReduce_228),-	(229 , happyReduce_229),-	(230 , happyReduce_230),-	(231 , happyReduce_231),-	(232 , happyReduce_232),-	(233 , happyReduce_233),-	(234 , happyReduce_234),-	(235 , happyReduce_235),-	(236 , happyReduce_236),-	(237 , happyReduce_237),-	(238 , happyReduce_238),-	(239 , happyReduce_239),-	(240 , happyReduce_240),-	(241 , happyReduce_241),-	(242 , happyReduce_242),-	(243 , happyReduce_243),-	(244 , happyReduce_244),-	(245 , happyReduce_245),-	(246 , happyReduce_246),-	(247 , happyReduce_247),-	(248 , happyReduce_248),-	(249 , happyReduce_249),-	(250 , happyReduce_250),-	(251 , happyReduce_251),-	(252 , happyReduce_252),-	(253 , happyReduce_253),-	(254 , happyReduce_254),-	(255 , happyReduce_255),-	(256 , happyReduce_256),-	(257 , happyReduce_257),-	(258 , happyReduce_258),-	(259 , happyReduce_259),-	(260 , happyReduce_260),-	(261 , happyReduce_261),-	(262 , happyReduce_262),-	(263 , happyReduce_263),-	(264 , happyReduce_264),-	(265 , happyReduce_265),-	(266 , happyReduce_266),-	(267 , happyReduce_267),-	(268 , happyReduce_268),-	(269 , happyReduce_269),-	(270 , happyReduce_270),-	(271 , happyReduce_271),-	(272 , happyReduce_272),-	(273 , happyReduce_273),-	(274 , happyReduce_274),-	(275 , happyReduce_275),-	(276 , happyReduce_276),-	(277 , happyReduce_277),-	(278 , happyReduce_278),-	(279 , happyReduce_279),-	(280 , happyReduce_280),-	(281 , happyReduce_281),-	(282 , happyReduce_282),-	(283 , happyReduce_283),-	(284 , happyReduce_284),-	(285 , happyReduce_285),-	(286 , happyReduce_286),-	(287 , happyReduce_287),-	(288 , happyReduce_288),-	(289 , happyReduce_289),-	(290 , happyReduce_290),-	(291 , happyReduce_291),-	(292 , happyReduce_292),-	(293 , happyReduce_293),-	(294 , happyReduce_294),-	(295 , happyReduce_295),-	(296 , happyReduce_296),-	(297 , happyReduce_297),-	(298 , happyReduce_298),-	(299 , happyReduce_299),-	(300 , happyReduce_300),-	(301 , happyReduce_301),-	(302 , happyReduce_302),-	(303 , happyReduce_303),-	(304 , happyReduce_304),-	(305 , happyReduce_305),-	(306 , happyReduce_306),-	(307 , happyReduce_307),-	(308 , happyReduce_308),-	(309 , happyReduce_309),-	(310 , happyReduce_310),-	(311 , happyReduce_311),-	(312 , happyReduce_312),-	(313 , happyReduce_313),-	(314 , happyReduce_314),-	(315 , happyReduce_315),-	(316 , happyReduce_316),-	(317 , happyReduce_317),-	(318 , happyReduce_318),-	(319 , happyReduce_319),-	(320 , happyReduce_320),-	(321 , happyReduce_321),-	(322 , happyReduce_322),-	(323 , happyReduce_323),-	(324 , happyReduce_324),-	(325 , happyReduce_325),-	(326 , happyReduce_326),-	(327 , happyReduce_327),-	(328 , happyReduce_328),-	(329 , happyReduce_329),-	(330 , happyReduce_330),-	(331 , happyReduce_331),-	(332 , happyReduce_332),-	(333 , happyReduce_333),-	(334 , happyReduce_334),-	(335 , happyReduce_335),-	(336 , happyReduce_336),-	(337 , happyReduce_337),-	(338 , happyReduce_338),-	(339 , happyReduce_339),-	(340 , happyReduce_340),-	(341 , happyReduce_341),-	(342 , happyReduce_342),-	(343 , happyReduce_343),-	(344 , happyReduce_344),-	(345 , happyReduce_345),-	(346 , happyReduce_346),-	(347 , happyReduce_347),-	(348 , happyReduce_348),-	(349 , happyReduce_349),-	(350 , happyReduce_350),-	(351 , happyReduce_351),-	(352 , happyReduce_352),-	(353 , happyReduce_353),-	(354 , happyReduce_354),-	(355 , happyReduce_355),-	(356 , happyReduce_356),-	(357 , happyReduce_357),-	(358 , happyReduce_358),-	(359 , happyReduce_359),-	(360 , happyReduce_360),-	(361 , happyReduce_361),-	(362 , happyReduce_362),-	(363 , happyReduce_363),-	(364 , happyReduce_364),-	(365 , happyReduce_365),-	(366 , happyReduce_366),-	(367 , happyReduce_367),-	(368 , happyReduce_368),-	(369 , happyReduce_369),-	(370 , happyReduce_370),-	(371 , happyReduce_371),-	(372 , happyReduce_372),-	(373 , happyReduce_373),-	(374 , happyReduce_374),-	(375 , happyReduce_375),-	(376 , happyReduce_376),-	(377 , happyReduce_377),-	(378 , happyReduce_378),-	(379 , happyReduce_379),-	(380 , happyReduce_380),-	(381 , happyReduce_381),-	(382 , happyReduce_382),-	(383 , happyReduce_383),-	(384 , happyReduce_384),-	(385 , happyReduce_385),-	(386 , happyReduce_386),-	(387 , happyReduce_387),-	(388 , happyReduce_388),-	(389 , happyReduce_389),-	(390 , happyReduce_390),-	(391 , happyReduce_391),-	(392 , happyReduce_392),-	(393 , happyReduce_393),-	(394 , happyReduce_394),-	(395 , happyReduce_395),-	(396 , happyReduce_396),-	(397 , happyReduce_397),-	(398 , happyReduce_398),-	(399 , happyReduce_399),-	(400 , happyReduce_400),-	(401 , happyReduce_401),-	(402 , happyReduce_402),-	(403 , happyReduce_403),-	(404 , happyReduce_404),-	(405 , happyReduce_405),-	(406 , happyReduce_406),-	(407 , happyReduce_407),-	(408 , happyReduce_408),-	(409 , happyReduce_409),-	(410 , happyReduce_410),-	(411 , happyReduce_411),-	(412 , happyReduce_412),-	(413 , happyReduce_413),-	(414 , happyReduce_414),-	(415 , happyReduce_415),-	(416 , happyReduce_416),-	(417 , happyReduce_417),-	(418 , happyReduce_418),-	(419 , happyReduce_419),-	(420 , happyReduce_420),-	(421 , happyReduce_421),-	(422 , happyReduce_422),-	(423 , happyReduce_423),-	(424 , happyReduce_424),-	(425 , happyReduce_425),-	(426 , happyReduce_426),-	(427 , happyReduce_427),-	(428 , happyReduce_428),-	(429 , happyReduce_429),-	(430 , happyReduce_430),-	(431 , happyReduce_431),-	(432 , happyReduce_432),-	(433 , happyReduce_433),-	(434 , happyReduce_434),-	(435 , happyReduce_435),-	(436 , happyReduce_436),-	(437 , happyReduce_437),-	(438 , happyReduce_438),-	(439 , happyReduce_439),-	(440 , happyReduce_440),-	(441 , happyReduce_441),-	(442 , happyReduce_442),-	(443 , happyReduce_443),-	(444 , happyReduce_444),-	(445 , happyReduce_445),-	(446 , happyReduce_446),-	(447 , happyReduce_447),-	(448 , happyReduce_448),-	(449 , happyReduce_449),-	(450 , happyReduce_450),-	(451 , happyReduce_451),-	(452 , happyReduce_452),-	(453 , happyReduce_453),-	(454 , happyReduce_454),-	(455 , happyReduce_455),-	(456 , happyReduce_456),-	(457 , happyReduce_457),-	(458 , happyReduce_458),-	(459 , happyReduce_459),-	(460 , happyReduce_460),-	(461 , happyReduce_461),-	(462 , happyReduce_462),-	(463 , happyReduce_463),-	(464 , happyReduce_464),-	(465 , happyReduce_465),-	(466 , happyReduce_466),-	(467 , happyReduce_467),-	(468 , happyReduce_468),-	(469 , happyReduce_469),-	(470 , happyReduce_470),-	(471 , happyReduce_471),-	(472 , happyReduce_472),-	(473 , happyReduce_473),-	(474 , happyReduce_474),-	(475 , happyReduce_475),-	(476 , happyReduce_476),-	(477 , happyReduce_477),-	(478 , happyReduce_478),-	(479 , happyReduce_479),-	(480 , happyReduce_480),-	(481 , happyReduce_481),-	(482 , happyReduce_482),-	(483 , happyReduce_483),-	(484 , happyReduce_484),-	(485 , happyReduce_485),-	(486 , happyReduce_486),-	(487 , happyReduce_487),-	(488 , happyReduce_488),-	(489 , happyReduce_489),-	(490 , happyReduce_490),-	(491 , happyReduce_491),-	(492 , happyReduce_492),-	(493 , happyReduce_493),-	(494 , happyReduce_494),-	(495 , happyReduce_495),-	(496 , happyReduce_496),-	(497 , happyReduce_497),-	(498 , happyReduce_498),-	(499 , happyReduce_499),-	(500 , happyReduce_500),-	(501 , happyReduce_501),-	(502 , happyReduce_502),-	(503 , happyReduce_503),-	(504 , happyReduce_504),-	(505 , happyReduce_505),-	(506 , happyReduce_506),-	(507 , happyReduce_507),-	(508 , happyReduce_508),-	(509 , happyReduce_509),-	(510 , happyReduce_510),-	(511 , happyReduce_511),-	(512 , happyReduce_512),-	(513 , happyReduce_513),-	(514 , happyReduce_514),-	(515 , happyReduce_515),-	(516 , happyReduce_516),-	(517 , happyReduce_517),-	(518 , happyReduce_518),-	(519 , happyReduce_519),-	(520 , happyReduce_520),-	(521 , happyReduce_521),-	(522 , happyReduce_522),-	(523 , happyReduce_523),-	(524 , happyReduce_524),-	(525 , happyReduce_525),-	(526 , happyReduce_526),-	(527 , happyReduce_527),-	(528 , happyReduce_528),-	(529 , happyReduce_529),-	(530 , happyReduce_530),-	(531 , happyReduce_531),-	(532 , happyReduce_532),-	(533 , happyReduce_533),-	(534 , happyReduce_534),-	(535 , happyReduce_535),-	(536 , happyReduce_536),-	(537 , happyReduce_537),-	(538 , happyReduce_538),-	(539 , happyReduce_539),-	(540 , happyReduce_540),-	(541 , happyReduce_541),-	(542 , happyReduce_542),-	(543 , happyReduce_543),-	(544 , happyReduce_544),-	(545 , happyReduce_545),-	(546 , happyReduce_546),-	(547 , happyReduce_547),-	(548 , happyReduce_548),-	(549 , happyReduce_549),-	(550 , happyReduce_550),-	(551 , happyReduce_551),-	(552 , happyReduce_552),-	(553 , happyReduce_553),-	(554 , happyReduce_554),-	(555 , happyReduce_555),-	(556 , happyReduce_556),-	(557 , happyReduce_557),-	(558 , happyReduce_558),-	(559 , happyReduce_559),-	(560 , happyReduce_560),-	(561 , happyReduce_561),-	(562 , happyReduce_562),-	(563 , happyReduce_563),-	(564 , happyReduce_564),-	(565 , happyReduce_565),-	(566 , happyReduce_566),-	(567 , happyReduce_567),-	(568 , happyReduce_568),-	(569 , happyReduce_569),-	(570 , happyReduce_570),-	(571 , happyReduce_571),-	(572 , happyReduce_572),-	(573 , happyReduce_573),-	(574 , happyReduce_574),-	(575 , happyReduce_575),-	(576 , happyReduce_576),-	(577 , happyReduce_577),-	(578 , happyReduce_578),-	(579 , happyReduce_579),-	(580 , happyReduce_580),-	(581 , happyReduce_581),-	(582 , happyReduce_582),-	(583 , happyReduce_583),-	(584 , happyReduce_584),-	(585 , happyReduce_585),-	(586 , happyReduce_586),-	(587 , happyReduce_587),-	(588 , happyReduce_588),-	(589 , happyReduce_589),-	(590 , happyReduce_590),-	(591 , happyReduce_591),-	(592 , happyReduce_592),-	(593 , happyReduce_593),-	(594 , happyReduce_594),-	(595 , happyReduce_595),-	(596 , happyReduce_596),-	(597 , happyReduce_597),-	(598 , happyReduce_598),-	(599 , happyReduce_599),-	(600 , happyReduce_600),-	(601 , happyReduce_601),-	(602 , happyReduce_602),-	(603 , happyReduce_603),-	(604 , happyReduce_604),-	(605 , happyReduce_605),-	(606 , happyReduce_606),-	(607 , happyReduce_607),-	(608 , happyReduce_608),-	(609 , happyReduce_609),-	(610 , happyReduce_610),-	(611 , happyReduce_611),-	(612 , happyReduce_612),-	(613 , happyReduce_613),-	(614 , happyReduce_614),-	(615 , happyReduce_615),-	(616 , happyReduce_616),-	(617 , happyReduce_617),-	(618 , happyReduce_618),-	(619 , happyReduce_619),-	(620 , happyReduce_620),-	(621 , happyReduce_621),-	(622 , happyReduce_622),-	(623 , happyReduce_623),-	(624 , happyReduce_624),-	(625 , happyReduce_625),-	(626 , happyReduce_626),-	(627 , happyReduce_627),-	(628 , happyReduce_628),-	(629 , happyReduce_629),-	(630 , happyReduce_630),-	(631 , happyReduce_631),-	(632 , happyReduce_632),-	(633 , happyReduce_633),-	(634 , happyReduce_634),-	(635 , happyReduce_635),-	(636 , happyReduce_636),-	(637 , happyReduce_637),-	(638 , happyReduce_638),-	(639 , happyReduce_639),-	(640 , happyReduce_640),-	(641 , happyReduce_641),-	(642 , happyReduce_642),-	(643 , happyReduce_643),-	(644 , happyReduce_644),-	(645 , happyReduce_645),-	(646 , happyReduce_646),-	(647 , happyReduce_647),-	(648 , happyReduce_648),-	(649 , happyReduce_649),-	(650 , happyReduce_650),-	(651 , happyReduce_651),-	(652 , happyReduce_652),-	(653 , happyReduce_653),-	(654 , happyReduce_654),-	(655 , happyReduce_655),-	(656 , happyReduce_656),-	(657 , happyReduce_657),-	(658 , happyReduce_658),-	(659 , happyReduce_659),-	(660 , happyReduce_660),-	(661 , happyReduce_661),-	(662 , happyReduce_662),-	(663 , happyReduce_663),-	(664 , happyReduce_664),-	(665 , happyReduce_665),-	(666 , happyReduce_666),-	(667 , happyReduce_667),-	(668 , happyReduce_668),-	(669 , happyReduce_669),-	(670 , happyReduce_670),-	(671 , happyReduce_671),-	(672 , happyReduce_672),-	(673 , happyReduce_673),-	(674 , happyReduce_674),-	(675 , happyReduce_675),-	(676 , happyReduce_676),-	(677 , happyReduce_677),-	(678 , happyReduce_678),-	(679 , happyReduce_679),-	(680 , happyReduce_680),-	(681 , happyReduce_681),-	(682 , happyReduce_682),-	(683 , happyReduce_683),-	(684 , happyReduce_684),-	(685 , happyReduce_685),-	(686 , happyReduce_686),-	(687 , happyReduce_687),-	(688 , happyReduce_688),-	(689 , happyReduce_689),-	(690 , happyReduce_690),-	(691 , happyReduce_691),-	(692 , happyReduce_692),-	(693 , happyReduce_693),-	(694 , happyReduce_694),-	(695 , happyReduce_695),-	(696 , happyReduce_696),-	(697 , happyReduce_697),-	(698 , happyReduce_698),-	(699 , happyReduce_699),-	(700 , happyReduce_700),-	(701 , happyReduce_701),-	(702 , happyReduce_702),-	(703 , happyReduce_703),-	(704 , happyReduce_704),-	(705 , happyReduce_705),-	(706 , happyReduce_706),-	(707 , happyReduce_707),-	(708 , happyReduce_708),-	(709 , happyReduce_709),-	(710 , happyReduce_710),-	(711 , happyReduce_711),-	(712 , happyReduce_712),-	(713 , happyReduce_713),-	(714 , happyReduce_714),-	(715 , happyReduce_715),-	(716 , happyReduce_716),-	(717 , happyReduce_717),-	(718 , happyReduce_718),-	(719 , happyReduce_719),-	(720 , happyReduce_720),-	(721 , happyReduce_721),-	(722 , happyReduce_722),-	(723 , happyReduce_723),-	(724 , happyReduce_724),-	(725 , happyReduce_725),-	(726 , happyReduce_726),-	(727 , happyReduce_727),-	(728 , happyReduce_728),-	(729 , happyReduce_729),-	(730 , happyReduce_730),-	(731 , happyReduce_731),-	(732 , happyReduce_732),-	(733 , happyReduce_733),-	(734 , happyReduce_734),-	(735 , happyReduce_735),-	(736 , happyReduce_736),-	(737 , happyReduce_737),-	(738 , happyReduce_738),-	(739 , happyReduce_739),-	(740 , happyReduce_740),-	(741 , happyReduce_741),-	(742 , happyReduce_742),-	(743 , happyReduce_743),-	(744 , happyReduce_744),-	(745 , happyReduce_745),-	(746 , happyReduce_746),-	(747 , happyReduce_747),-	(748 , happyReduce_748),-	(749 , happyReduce_749),-	(750 , happyReduce_750),-	(751 , happyReduce_751),-	(752 , happyReduce_752),-	(753 , happyReduce_753),-	(754 , happyReduce_754),-	(755 , happyReduce_755),-	(756 , happyReduce_756),-	(757 , happyReduce_757),-	(758 , happyReduce_758),-	(759 , happyReduce_759),-	(760 , happyReduce_760),-	(761 , happyReduce_761),-	(762 , happyReduce_762),-	(763 , happyReduce_763),-	(764 , happyReduce_764),-	(765 , happyReduce_765),-	(766 , happyReduce_766),-	(767 , happyReduce_767),-	(768 , happyReduce_768),-	(769 , happyReduce_769),-	(770 , happyReduce_770),-	(771 , happyReduce_771),-	(772 , happyReduce_772),-	(773 , happyReduce_773),-	(774 , happyReduce_774),-	(775 , happyReduce_775),-	(776 , happyReduce_776),-	(777 , happyReduce_777),-	(778 , happyReduce_778),-	(779 , happyReduce_779),-	(780 , happyReduce_780),-	(781 , happyReduce_781),-	(782 , happyReduce_782),-	(783 , happyReduce_783),-	(784 , happyReduce_784),-	(785 , happyReduce_785),-	(786 , happyReduce_786),-	(787 , happyReduce_787),-	(788 , happyReduce_788),-	(789 , happyReduce_789),-	(790 , happyReduce_790),-	(791 , happyReduce_791),-	(792 , happyReduce_792),-	(793 , happyReduce_793),-	(794 , happyReduce_794),-	(795 , happyReduce_795),-	(796 , happyReduce_796),-	(797 , happyReduce_797),-	(798 , happyReduce_798),-	(799 , happyReduce_799),-	(800 , happyReduce_800),-	(801 , happyReduce_801),-	(802 , happyReduce_802),-	(803 , happyReduce_803),-	(804 , happyReduce_804),-	(805 , happyReduce_805),-	(806 , happyReduce_806),-	(807 , happyReduce_807),-	(808 , happyReduce_808),-	(809 , happyReduce_809),-	(810 , happyReduce_810),-	(811 , happyReduce_811),-	(812 , happyReduce_812),-	(813 , happyReduce_813),-	(814 , happyReduce_814),-	(815 , happyReduce_815),-	(816 , happyReduce_816),-	(817 , happyReduce_817),-	(818 , happyReduce_818),-	(819 , happyReduce_819),-	(820 , happyReduce_820),-	(821 , happyReduce_821),-	(822 , happyReduce_822),-	(823 , happyReduce_823),-	(824 , happyReduce_824),-	(825 , happyReduce_825),-	(826 , happyReduce_826)-	]--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 )-happyReduce_13 = happySpecReduce_1  0# happyReduction_13-happyReduction_13 happy_x_1-	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> -	happyIn16-		 (happy_var_1-	)}--happyReduce_14 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_14 = happySpecReduce_1  0# happyReduction_14-happyReduction_14 happy_x_1-	 =  case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> -	happyIn16-		 (happy_var_1-	)}--happyReduce_15 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_15 = happySpecReduce_1  0# happyReduction_15-happyReduction_15 happy_x_1-	 =  case happyOut296 happy_x_1 of { (HappyWrap296 happy_var_1) -> -	happyIn16-		 (happy_var_1-	)}--happyReduce_16 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_16 = happySpecReduce_1  0# happyReduction_16-happyReduction_16 happy_x_1-	 =  case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> -	happyIn16-		 (happy_var_1-	)}--happyReduce_17 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_17 = happyMonadReduce 3# 0# happyReduction_17-happyReduction_17 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)-                               [mop happy_var_1,mu AnnRarrow happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn16 r))--happyReduce_18 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_18 = happySpecReduce_3  1# happyReduction_18-happyReduction_18 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> -	happyIn17-		 (fromOL happy_var_2-	)}--happyReduce_19 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_19 = happySpecReduce_3  1# happyReduction_19-happyReduction_19 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> -	happyIn17-		 (fromOL happy_var_2-	)}--happyReduce_20 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_20 = happySpecReduce_3  2# happyReduction_20-happyReduction_20 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut18 happy_x_1 of { (HappyWrap18 happy_var_1) -> -	case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> -	happyIn18-		 (happy_var_1 `appOL` unitOL happy_var_3-	)}}--happyReduce_21 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_21 = happySpecReduce_2  2# happyReduction_21-happyReduction_21 happy_x_2-	happy_x_1-	 =  case happyOut18 happy_x_1 of { (HappyWrap18 happy_var_1) -> -	happyIn18-		 (happy_var_1-	)}--happyReduce_22 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_22 = happySpecReduce_1  2# happyReduction_22-happyReduction_22 happy_x_1-	 =  case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> -	happyIn18-		 (unitOL happy_var_1-	)}--happyReduce_23 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_23 = happyReduce 4# 3# happyReduction_23-happyReduction_23 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut24 happy_x_2 of { (HappyWrap24 happy_var_2) -> -	case happyOut30 happy_x_4 of { (HappyWrap30 happy_var_4) -> -	happyIn19-		 (sL1 happy_var_1 $ HsUnit { hsunitName = happy_var_2-                              , hsunitBody = fromOL happy_var_4 }-	) `HappyStk` happyRest}}}--happyReduce_24 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_24 = happySpecReduce_1  4# happyReduction_24-happyReduction_24 happy_x_1-	 =  case happyOut24 happy_x_1 of { (HappyWrap24 happy_var_1) -> -	happyIn20-		 (sL1 happy_var_1 $ HsUnitId happy_var_1 []-	)}--happyReduce_25 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_25 = happyReduce 4# 4# happyReduction_25-happyReduction_25 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut24 happy_x_1 of { (HappyWrap24 happy_var_1) -> -	case happyOut21 happy_x_3 of { (HappyWrap21 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn20-		 (sLL happy_var_1 happy_var_4 $ HsUnitId happy_var_1 (fromOL happy_var_3)-	) `HappyStk` happyRest}}}--happyReduce_26 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_26 = happySpecReduce_3  5# happyReduction_26-happyReduction_26 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> -	case happyOut22 happy_x_3 of { (HappyWrap22 happy_var_3) -> -	happyIn21-		 (happy_var_1 `appOL` unitOL happy_var_3-	)}}--happyReduce_27 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_27 = happySpecReduce_2  5# happyReduction_27-happyReduction_27 happy_x_2-	happy_x_1-	 =  case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> -	happyIn21-		 (happy_var_1-	)}--happyReduce_28 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_28 = happySpecReduce_1  5# happyReduction_28-happyReduction_28 happy_x_1-	 =  case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> -	happyIn21-		 (unitOL happy_var_1-	)}--happyReduce_29 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_29 = happySpecReduce_3  6# happyReduction_29-happyReduction_29 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> -	case happyOut23 happy_x_3 of { (HappyWrap23 happy_var_3) -> -	happyIn22-		 (sLL happy_var_1 happy_var_3 $ (happy_var_1, happy_var_3)-	)}}--happyReduce_30 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_30 = happyReduce 4# 6# happyReduction_30-happyReduction_30 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn22-		 (sLL happy_var_1 happy_var_4 $ (happy_var_1, sLL happy_var_2 happy_var_4 $ HsModuleVar happy_var_3)-	) `HappyStk` happyRest}}}}--happyReduce_31 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_31 = happySpecReduce_3  7# happyReduction_31-happyReduction_31 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn23-		 (sLL happy_var_1 happy_var_3 $ HsModuleVar happy_var_2-	)}}}--happyReduce_32 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_32 = happySpecReduce_3  7# happyReduction_32-happyReduction_32 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut20 happy_x_1 of { (HappyWrap20 happy_var_1) -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	happyIn23-		 (sLL happy_var_1 happy_var_3 $ HsModuleId happy_var_1 happy_var_3-	)}}--happyReduce_33 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_33 = happySpecReduce_1  8# happyReduction_33-happyReduction_33 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn24-		 (sL1 happy_var_1 $ PackageName (getSTRING happy_var_1)-	)}--happyReduce_34 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_34 = happySpecReduce_1  8# happyReduction_34-happyReduction_34 happy_x_1-	 =  case happyOut26 happy_x_1 of { (HappyWrap26 happy_var_1) -> -	happyIn24-		 (sL1 happy_var_1 $ PackageName (unLoc happy_var_1)-	)}--happyReduce_35 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_35 = happySpecReduce_1  9# happyReduction_35-happyReduction_35 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn25-		 (sL1 happy_var_1 $ getVARID happy_var_1-	)}--happyReduce_36 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_36 = happySpecReduce_1  9# happyReduction_36-happyReduction_36 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn25-		 (sL1 happy_var_1 $ getCONID happy_var_1-	)}--happyReduce_37 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_37 = happySpecReduce_1  9# happyReduction_37-happyReduction_37 happy_x_1-	 =  case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> -	happyIn25-		 (happy_var_1-	)}--happyReduce_38 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_38 = happySpecReduce_1  10# happyReduction_38-happyReduction_38 happy_x_1-	 =  case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> -	happyIn26-		 (happy_var_1-	)}--happyReduce_39 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_39 = happySpecReduce_3  10# happyReduction_39-happyReduction_39 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> -	case happyOut26 happy_x_3 of { (HappyWrap26 happy_var_3) -> -	happyIn26-		 (sLL happy_var_1 happy_var_3 $ appendFS (unLoc happy_var_1) (consFS '-' (unLoc happy_var_3))-	)}}--happyReduce_40 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_40 = happySpecReduce_0  11# happyReduction_40-happyReduction_40  =  happyIn27-		 (Nothing-	)--happyReduce_41 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_41 = happySpecReduce_3  11# happyReduction_41-happyReduction_41 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_2 of { (HappyWrap28 happy_var_2) -> -	happyIn27-		 (Just (fromOL happy_var_2)-	)}--happyReduce_42 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_42 = happySpecReduce_3  12# happyReduction_42-happyReduction_42 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> -	case happyOut29 happy_x_3 of { (HappyWrap29 happy_var_3) -> -	happyIn28-		 (happy_var_1 `appOL` unitOL happy_var_3-	)}}--happyReduce_43 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_43 = happySpecReduce_2  12# happyReduction_43-happyReduction_43 happy_x_2-	happy_x_1-	 =  case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> -	happyIn28-		 (happy_var_1-	)}--happyReduce_44 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_44 = happySpecReduce_1  12# happyReduction_44-happyReduction_44 happy_x_1-	 =  case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> -	happyIn28-		 (unitOL happy_var_1-	)}--happyReduce_45 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_45 = happySpecReduce_3  13# happyReduction_45-happyReduction_45 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	happyIn29-		 (sLL happy_var_1 happy_var_3 $ Renaming happy_var_1 (Just happy_var_3)-	)}}--happyReduce_46 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_46 = happySpecReduce_1  13# happyReduction_46-happyReduction_46 happy_x_1-	 =  case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> -	happyIn29-		 (sL1 happy_var_1    $ Renaming happy_var_1 Nothing-	)}--happyReduce_47 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_47 = happySpecReduce_3  14# happyReduction_47-happyReduction_47 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut31 happy_x_2 of { (HappyWrap31 happy_var_2) -> -	happyIn30-		 (happy_var_2-	)}--happyReduce_48 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_48 = happySpecReduce_3  14# happyReduction_48-happyReduction_48 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut31 happy_x_2 of { (HappyWrap31 happy_var_2) -> -	happyIn30-		 (happy_var_2-	)}--happyReduce_49 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_49 = happySpecReduce_3  15# happyReduction_49-happyReduction_49 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> -	case happyOut32 happy_x_3 of { (HappyWrap32 happy_var_3) -> -	happyIn31-		 (happy_var_1 `appOL` unitOL happy_var_3-	)}}--happyReduce_50 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_50 = happySpecReduce_2  15# happyReduction_50-happyReduction_50 happy_x_2-	happy_x_1-	 =  case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> -	happyIn31-		 (happy_var_1-	)}--happyReduce_51 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_51 = happySpecReduce_1  15# happyReduction_51-happyReduction_51 happy_x_1-	 =  case happyOut32 happy_x_1 of { (HappyWrap32 happy_var_1) -> -	happyIn31-		 (unitOL happy_var_1-	)}--happyReduce_52 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_52 = happyReduce 8# 16# happyReduction_52-happyReduction_52 (happy_x_8 `HappyStk`-	happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> -	case happyOut318 happy_x_4 of { (HappyWrap318 happy_var_4) -> -	case happyOut38 happy_x_5 of { (HappyWrap38 happy_var_5) -> -	case happyOut48 happy_x_6 of { (HappyWrap48 happy_var_6) -> -	case happyOut39 happy_x_8 of { (HappyWrap39 happy_var_8) -> -	happyIn32-		 (sL1 happy_var_2 $ DeclD-                 (case snd happy_var_3 of-                   False -> HsSrcFile-                   True  -> HsBootFile)-                 happy_var_4-                 (Just $ sL1 happy_var_2 (HsModule (Just happy_var_4) happy_var_6 (fst $ snd happy_var_8) (snd $ snd happy_var_8) happy_var_5 happy_var_1))-	) `HappyStk` happyRest}}}}}}}--happyReduce_53 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_53 = happyReduce 7# 16# happyReduction_53-happyReduction_53 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> -	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> -	case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> -	happyIn32-		 (sL1 happy_var_2 $ DeclD-                 HsigFile-                 happy_var_3-                 (Just $ sL1 happy_var_2 (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7) (snd $ snd happy_var_7) happy_var_4 happy_var_1))-	) `HappyStk` happyRest}}}}}}--happyReduce_54 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_54 = happyReduce 4# 16# happyReduction_54-happyReduction_54 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut65 happy_x_3 of { (HappyWrap65 happy_var_3) -> -	case happyOut318 happy_x_4 of { (HappyWrap318 happy_var_4) -> -	happyIn32-		 (sL1 happy_var_2 $ DeclD (case snd happy_var_3 of-                   False -> HsSrcFile-                   True  -> HsBootFile) happy_var_4 Nothing-	) `HappyStk` happyRest}}}--happyReduce_55 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_55 = happySpecReduce_3  16# happyReduction_55-happyReduction_55 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	happyIn32-		 (sL1 happy_var_2 $ DeclD HsigFile happy_var_3 Nothing-	)}}--happyReduce_56 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_56 = happySpecReduce_3  16# happyReduction_56-happyReduction_56 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut20 happy_x_2 of { (HappyWrap20 happy_var_2) -> -	case happyOut27 happy_x_3 of { (HappyWrap27 happy_var_3) -> -	happyIn32-		 (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_2-                                              , idModRenaming = happy_var_3-                                              , idSignatureInclude = False })-	)}}}--happyReduce_57 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_57 = happySpecReduce_3  16# happyReduction_57-happyReduction_57 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> -	happyIn32-		 (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_3-                                              , idModRenaming = Nothing-                                              , idSignatureInclude = True })-	)}}--happyReduce_58 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_58 = happyMonadReduce 7# 17# happyReduction_58-happyReduction_58 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> -	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> -	( fileSrcSpan >>= \ loc ->-                ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)-                              (snd $ snd happy_var_7) happy_var_4 happy_var_1)-                    )-                    ([mj AnnSignature happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})-	) (\r -> happyReturn (happyIn33 r))--happyReduce_59 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_59 = happyMonadReduce 7# 18# happyReduction_59-happyReduction_59 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> -	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> -	( fileSrcSpan >>= \ loc ->-                ams (L loc (HsModule (Just happy_var_3) happy_var_5 (fst $ snd happy_var_7)-                              (snd $ snd happy_var_7) happy_var_4 happy_var_1)-                    )-                    ([mj AnnModule happy_var_2, mj AnnWhere happy_var_6] ++ fst happy_var_7))}}}}}}})-	) (\r -> happyReturn (happyIn34 r))--happyReduce_60 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_60 = happyMonadReduce 1# 18# happyReduction_60-happyReduction_60 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut40 happy_x_1 of { (HappyWrap40 happy_var_1) -> -	( fileSrcSpan >>= \ loc ->-                   ams (L loc (HsModule Nothing Nothing-                               (fst $ snd happy_var_1) (snd $ snd happy_var_1) Nothing Nothing))-                       (fst happy_var_1))})-	) (\r -> happyReturn (happyIn34 r))--happyReduce_61 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_61 = happySpecReduce_1  19# happyReduction_61-happyReduction_61 happy_x_1-	 =  case happyOut326 happy_x_1 of { (HappyWrap326 happy_var_1) -> -	happyIn35-		 (happy_var_1-	)}--happyReduce_62 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_62 = happySpecReduce_0  19# happyReduction_62-happyReduction_62  =  happyIn35-		 (Nothing-	)--happyReduce_63 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_63 = happyMonadReduce 0# 20# happyReduction_63-happyReduction_63 (happyRest) tk-	 = happyThen ((( pushModuleContext))-	) (\r -> happyReturn (happyIn36 r))--happyReduce_64 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_64 = happyMonadReduce 0# 21# happyReduction_64-happyReduction_64 (happyRest) tk-	 = happyThen ((( pushModuleContext))-	) (\r -> happyReturn (happyIn37 r))--happyReduce_65 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_65 = happyMonadReduce 3# 22# happyReduction_65-happyReduction_65 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ajs (sLL happy_var_1 happy_var_3 $ DeprecatedTxt (sL1 happy_var_1 (getDEPRECATED_PRAGs happy_var_1)) (snd $ unLoc happy_var_2))-                             (mo happy_var_1:mc happy_var_3: (fst $ unLoc happy_var_2)))}}})-	) (\r -> happyReturn (happyIn38 r))--happyReduce_66 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_66 = happyMonadReduce 3# 22# happyReduction_66-happyReduction_66 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ajs (sLL happy_var_1 happy_var_3 $ WarningTxt (sL1 happy_var_1 (getWARNING_PRAGs happy_var_1)) (snd $ unLoc happy_var_2))-                                (mo happy_var_1:mc happy_var_3 : (fst $ unLoc happy_var_2)))}}})-	) (\r -> happyReturn (happyIn38 r))--happyReduce_67 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_67 = happySpecReduce_0  22# happyReduction_67-happyReduction_67  =  happyIn38-		 (Nothing-	)--happyReduce_68 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_68 = happySpecReduce_3  23# happyReduction_68-happyReduction_68 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn39-		 ((moc happy_var_1:mcc happy_var_3:(fst happy_var_2)-                                         , snd happy_var_2)-	)}}}--happyReduce_69 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_69 = happySpecReduce_3  23# happyReduction_69-happyReduction_69 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> -	happyIn39-		 ((fst happy_var_2, snd happy_var_2)-	)}--happyReduce_70 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_70 = happySpecReduce_3  24# happyReduction_70-happyReduction_70 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn40-		 ((moc happy_var_1:mcc happy_var_3-                                                   :(fst happy_var_2), snd happy_var_2)-	)}}}--happyReduce_71 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_71 = happySpecReduce_3  24# happyReduction_71-happyReduction_71 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> -	happyIn40-		 (([],snd happy_var_2)-	)}--happyReduce_72 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_72 = happySpecReduce_2  25# happyReduction_72-happyReduction_72 happy_x_2-	happy_x_1-	 =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> -	case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> -	happyIn41-		 ((happy_var_1, happy_var_2)-	)}}--happyReduce_73 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_73 = happySpecReduce_2  26# happyReduction_73-happyReduction_73 happy_x_2-	happy_x_1-	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> -	case happyOut76 happy_x_2 of { (HappyWrap76 happy_var_2) -> -	happyIn42-		 ((reverse happy_var_1, cvTopDecls happy_var_2)-	)}}--happyReduce_74 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_74 = happySpecReduce_2  26# happyReduction_74-happyReduction_74 happy_x_2-	happy_x_1-	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> -	case happyOut75 happy_x_2 of { (HappyWrap75 happy_var_2) -> -	happyIn42-		 ((reverse happy_var_1, cvTopDecls happy_var_2)-	)}}--happyReduce_75 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_75 = happySpecReduce_1  26# happyReduction_75-happyReduction_75 happy_x_1-	 =  case happyOut62 happy_x_1 of { (HappyWrap62 happy_var_1) -> -	happyIn42-		 ((reverse happy_var_1, [])-	)}--happyReduce_76 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_76 = happyMonadReduce 7# 27# happyReduction_76-happyReduction_76 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> -	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	case happyOut44 happy_x_7 of { (HappyWrap44 happy_var_7) -> -	( fileSrcSpan >>= \ loc ->-                   ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1-                          )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})-	) (\r -> happyReturn (happyIn43 r))--happyReduce_77 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_77 = happyMonadReduce 7# 27# happyReduction_77-happyReduction_77 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut318 happy_x_3 of { (HappyWrap318 happy_var_3) -> -	case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> -	case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	case happyOut44 happy_x_7 of { (HappyWrap44 happy_var_7) -> -	( fileSrcSpan >>= \ loc ->-                   ams (L loc (HsModule (Just happy_var_3) happy_var_5 happy_var_7 [] happy_var_4 happy_var_1-                          )) [mj AnnModule happy_var_2,mj AnnWhere happy_var_6])}}}}}}})-	) (\r -> happyReturn (happyIn43 r))--happyReduce_78 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_78 = happyMonadReduce 1# 27# happyReduction_78-happyReduction_78 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> -	( fileSrcSpan >>= \ loc ->-                   return (L loc (HsModule Nothing Nothing happy_var_1 [] Nothing-                          Nothing)))})-	) (\r -> happyReturn (happyIn43 r))--happyReduce_79 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_79 = happySpecReduce_2  28# happyReduction_79-happyReduction_79 happy_x_2-	happy_x_1-	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> -	happyIn44-		 (happy_var_2-	)}--happyReduce_80 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_80 = happySpecReduce_2  28# happyReduction_80-happyReduction_80 happy_x_2-	happy_x_1-	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> -	happyIn44-		 (happy_var_2-	)}--happyReduce_81 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_81 = happySpecReduce_2  29# happyReduction_81-happyReduction_81 happy_x_2-	happy_x_1-	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> -	happyIn45-		 (happy_var_2-	)}--happyReduce_82 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_82 = happySpecReduce_2  29# happyReduction_82-happyReduction_82 happy_x_2-	happy_x_1-	 =  case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> -	happyIn45-		 (happy_var_2-	)}--happyReduce_83 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_83 = happySpecReduce_2  30# happyReduction_83-happyReduction_83 happy_x_2-	happy_x_1-	 =  case happyOut47 happy_x_2 of { (HappyWrap47 happy_var_2) -> -	happyIn46-		 (happy_var_2-	)}--happyReduce_84 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_84 = happySpecReduce_1  31# happyReduction_84-happyReduction_84 happy_x_1-	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> -	happyIn47-		 (happy_var_1-	)}--happyReduce_85 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_85 = happySpecReduce_1  31# happyReduction_85-happyReduction_85 happy_x_1-	 =  case happyOut62 happy_x_1 of { (HappyWrap62 happy_var_1) -> -	happyIn47-		 (happy_var_1-	)}--happyReduce_86 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_86 = happyMonadReduce 3# 32# happyReduction_86-happyReduction_86 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( amsL (comb2 happy_var_1 happy_var_3) [mop happy_var_1,mcp happy_var_3] >>-                                       return (Just (sLL happy_var_1 happy_var_3 (fromOL happy_var_2))))}}})-	) (\r -> happyReturn (happyIn48 r))--happyReduce_87 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_87 = happySpecReduce_0  32# happyReduction_87-happyReduction_87  =  happyIn48-		 (Nothing-	)--happyReduce_88 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_88 = happyMonadReduce 3# 33# happyReduction_88-happyReduction_88 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> -	( addAnnotation (oll happy_var_1) AnnComma (gl happy_var_2)-                                         >> return (happy_var_1 `appOL` happy_var_3))}}})-	) (\r -> happyReturn (happyIn49 r))--happyReduce_89 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_89 = happySpecReduce_1  33# happyReduction_89-happyReduction_89 happy_x_1-	 =  case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> -	happyIn49-		 (happy_var_1-	)}--happyReduce_90 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_90 = happyMonadReduce 5# 34# happyReduction_90-happyReduction_90 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> -	case happyOut53 happy_x_2 of { (HappyWrap53 happy_var_2) -> -	case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut50 happy_x_5 of { (HappyWrap50 happy_var_5) -> -	( (addAnnotation (oll (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3))-                                            AnnComma (gl happy_var_4) ) >>-                              return (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3 `appOL` happy_var_5))}}}}})-	) (\r -> happyReturn (happyIn50 r))--happyReduce_91 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_91 = happySpecReduce_3  34# happyReduction_91-happyReduction_91 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> -	case happyOut53 happy_x_2 of { (HappyWrap53 happy_var_2) -> -	case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> -	happyIn50-		 (happy_var_1 `appOL` happy_var_2 `appOL` happy_var_3-	)}}}--happyReduce_92 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_92 = happySpecReduce_1  34# happyReduction_92-happyReduction_92 happy_x_1-	 =  case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> -	happyIn50-		 (happy_var_1-	)}--happyReduce_93 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_93 = happySpecReduce_2  35# happyReduction_93-happyReduction_93 happy_x_2-	happy_x_1-	 =  case happyOut52 happy_x_1 of { (HappyWrap52 happy_var_1) -> -	case happyOut51 happy_x_2 of { (HappyWrap51 happy_var_2) -> -	happyIn51-		 (happy_var_1 `appOL` happy_var_2-	)}}--happyReduce_94 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_94 = happySpecReduce_0  35# happyReduction_94-happyReduction_94  =  happyIn51-		 (nilOL-	)--happyReduce_95 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_95 = happySpecReduce_1  36# happyReduction_95-happyReduction_95 happy_x_1-	 =  case happyOut325 happy_x_1 of { (HappyWrap325 happy_var_1) -> -	happyIn52-		 (unitOL (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> IEGroup noExtField n doc))-	)}--happyReduce_96 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_96 = happySpecReduce_1  36# happyReduction_96-happyReduction_96 happy_x_1-	 =  case happyOut324 happy_x_1 of { (HappyWrap324 happy_var_1) -> -	happyIn52-		 (unitOL (sL1 happy_var_1 (IEDocNamed noExtField ((fst . unLoc) happy_var_1)))-	)}--happyReduce_97 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_97 = happySpecReduce_1  36# happyReduction_97-happyReduction_97 happy_x_1-	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> -	happyIn52-		 (unitOL (sL1 happy_var_1 (IEDoc noExtField (unLoc happy_var_1)))-	)}--happyReduce_98 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_98 = happyMonadReduce 2# 37# happyReduction_98-happyReduction_98 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> -	case happyOut54 happy_x_2 of { (HappyWrap54 happy_var_2) -> -	( mkModuleImpExp happy_var_1 (snd $ unLoc happy_var_2)-                                          >>= \ie -> amsu (sLL happy_var_1 happy_var_2 ie) (fst $ unLoc happy_var_2))}})-	) (\r -> happyReturn (happyIn53 r))--happyReduce_99 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_99 = happyMonadReduce 2# 37# happyReduction_99-happyReduction_99 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> -	( amsu (sLL happy_var_1 happy_var_2 (IEModuleContents noExtField happy_var_2))-                                             [mj AnnModule happy_var_1])}})-	) (\r -> happyReturn (happyIn53 r))--happyReduce_100 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_100 = happyMonadReduce 2# 37# happyReduction_100-happyReduction_100 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut273 happy_x_2 of { (HappyWrap273 happy_var_2) -> -	( amsu (sLL happy_var_1 happy_var_2 (IEVar noExtField (sLL happy_var_1 happy_var_2 (IEPattern happy_var_2))))-                                             [mj AnnPattern happy_var_1])}})-	) (\r -> happyReturn (happyIn53 r))--happyReduce_101 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_101 = happySpecReduce_0  38# happyReduction_101-happyReduction_101  =  happyIn54-		 (sL0 ([],ImpExpAbs)-	)--happyReduce_102 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_102 = happyMonadReduce 3# 38# happyReduction_102-happyReduction_102 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut55 happy_x_2 of { (HappyWrap55 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( mkImpExpSubSpec (reverse (snd happy_var_2))-                                      >>= \(as,ie) -> return $ sLL happy_var_1 happy_var_3-                                            (as ++ [mop happy_var_1,mcp happy_var_3] ++ fst happy_var_2, ie))}}})-	) (\r -> happyReturn (happyIn54 r))--happyReduce_103 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_103 = happySpecReduce_0  39# happyReduction_103-happyReduction_103  =  happyIn55-		 (([],[])-	)--happyReduce_104 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_104 = happySpecReduce_1  39# happyReduction_104-happyReduction_104 happy_x_1-	 =  case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> -	happyIn55-		 (happy_var_1-	)}--happyReduce_105 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_105 = happyMonadReduce 3# 40# happyReduction_105-happyReduction_105 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut57 happy_x_3 of { (HappyWrap57 happy_var_3) -> -	( case (head (snd happy_var_1)) of-                                                    l@(L _ ImpExpQcWildcard) ->-                                                       return ([mj AnnComma happy_var_2, mj AnnDotdot l]-                                                               ,(snd (unLoc happy_var_3)  : snd happy_var_1))-                                                    l -> (ams (head (snd happy_var_1)) [mj AnnComma happy_var_2] >>-                                                          return (fst happy_var_1 ++ fst (unLoc happy_var_3),-                                                                  snd (unLoc happy_var_3) : snd happy_var_1)))}}})-	) (\r -> happyReturn (happyIn56 r))--happyReduce_106 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_106 = happySpecReduce_1  40# happyReduction_106-happyReduction_106 happy_x_1-	 =  case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> -	happyIn56-		 ((fst (unLoc happy_var_1),[snd (unLoc happy_var_1)])-	)}--happyReduce_107 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_107 = happySpecReduce_1  41# happyReduction_107-happyReduction_107 happy_x_1-	 =  case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> -	happyIn57-		 (sL1 happy_var_1 ([],happy_var_1)-	)}--happyReduce_108 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_108 = happySpecReduce_1  41# happyReduction_108-happyReduction_108 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn57-		 (sL1 happy_var_1 ([mj AnnDotdot happy_var_1], sL1 happy_var_1 ImpExpQcWildcard)-	)}--happyReduce_109 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_109 = happySpecReduce_1  42# happyReduction_109-happyReduction_109 happy_x_1-	 =  case happyOut59 happy_x_1 of { (HappyWrap59 happy_var_1) -> -	happyIn58-		 (sL1 happy_var_1 (ImpExpQcName happy_var_1)-	)}--happyReduce_110 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_110 = happyMonadReduce 2# 42# happyReduction_110-happyReduction_110 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut283 happy_x_2 of { (HappyWrap283 happy_var_2) -> -	( do { n <- mkTypeImpExp happy_var_2-                                          ; ams (sLL happy_var_1 happy_var_2 (ImpExpQcType n))-                                                [mj AnnType happy_var_1] })}})-	) (\r -> happyReturn (happyIn58 r))--happyReduce_111 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_111 = happySpecReduce_1  43# happyReduction_111-happyReduction_111 happy_x_1-	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> -	happyIn59-		 (happy_var_1-	)}--happyReduce_112 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_112 = happySpecReduce_1  43# happyReduction_112-happyReduction_112 happy_x_1-	 =  case happyOut284 happy_x_1 of { (HappyWrap284 happy_var_1) -> -	happyIn59-		 (happy_var_1-	)}--happyReduce_113 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_113 = happySpecReduce_2  44# happyReduction_113-happyReduction_113 happy_x_2-	happy_x_1-	 =  case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn60-		 (mj AnnSemi happy_var_2 : happy_var_1-	)}}--happyReduce_114 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_114 = happySpecReduce_1  44# happyReduction_114-happyReduction_114 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn60-		 ([mj AnnSemi happy_var_1]-	)}--happyReduce_115 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_115 = happySpecReduce_2  45# happyReduction_115-happyReduction_115 happy_x_2-	happy_x_1-	 =  case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn61-		 (mj AnnSemi happy_var_2 : happy_var_1-	)}}--happyReduce_116 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_116 = happySpecReduce_0  45# happyReduction_116-happyReduction_116  =  happyIn61-		 ([]-	)--happyReduce_117 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_117 = happySpecReduce_2  46# happyReduction_117-happyReduction_117 happy_x_2-	happy_x_1-	 =  case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> -	case happyOut64 happy_x_2 of { (HappyWrap64 happy_var_2) -> -	happyIn62-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_118 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_118 = happyMonadReduce 3# 47# happyReduction_118-happyReduction_118 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> -	case happyOut64 happy_x_2 of { (HappyWrap64 happy_var_2) -> -	case happyOut60 happy_x_3 of { (HappyWrap60 happy_var_3) -> -	( ams happy_var_2 happy_var_3 >> return (happy_var_2 : happy_var_1))}}})-	) (\r -> happyReturn (happyIn63 r))--happyReduce_119 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_119 = happySpecReduce_0  47# happyReduction_119-happyReduction_119  =  happyIn63-		 ([]-	)--happyReduce_120 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_120 = happyMonadReduce 9# 48# happyReduction_120-happyReduction_120 (happy_x_9 `HappyStk`-	happy_x_8 `HappyStk`-	happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut65 happy_x_2 of { (HappyWrap65 happy_var_2) -> -	case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> -	case happyOut68 happy_x_4 of { (HappyWrap68 happy_var_4) -> -	case happyOut67 happy_x_5 of { (HappyWrap67 happy_var_5) -> -	case happyOut318 happy_x_6 of { (HappyWrap318 happy_var_6) -> -	case happyOut68 happy_x_7 of { (HappyWrap68 happy_var_7) -> -	case happyOut69 happy_x_8 of { (HappyWrap69 happy_var_8) -> -	case happyOut70 happy_x_9 of { (HappyWrap70 happy_var_9) -> -	( do {-                  ; checkImportDecl happy_var_4 happy_var_7-                  ; ams (L (comb4 happy_var_1 happy_var_6 (snd happy_var_8) happy_var_9) $-                      ImportDecl { ideclExt = noExtField-                                  , ideclSourceSrc = snd $ fst happy_var_2-                                  , ideclName = happy_var_6, ideclPkgQual = snd happy_var_5-                                  , ideclSource = snd happy_var_2, ideclSafe = snd happy_var_3-                                  , ideclQualified = importDeclQualifiedStyle happy_var_4 happy_var_7-                                  , ideclImplicit = False-                                  , ideclAs = unLoc (snd happy_var_8)-                                  , ideclHiding = unLoc happy_var_9 })-                         (mj AnnImport happy_var_1 : fst (fst happy_var_2) ++ fst happy_var_3 ++ fmap (mj AnnQualified) (maybeToList happy_var_4)-                                          ++ fst happy_var_5 ++ fmap (mj AnnQualified) (maybeToList happy_var_7) ++ fst happy_var_8)-                  })}}}}}}}}})-	) (\r -> happyReturn (happyIn64 r))--happyReduce_121 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_121 = happySpecReduce_2  49# happyReduction_121-happyReduction_121 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn65-		 ((([mo happy_var_1,mc happy_var_2],getSOURCE_PRAGs happy_var_1)-                                      , True)-	)}}--happyReduce_122 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_122 = happySpecReduce_0  49# happyReduction_122-happyReduction_122  =  happyIn65-		 ((([],NoSourceText),False)-	)--happyReduce_123 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_123 = happySpecReduce_1  50# happyReduction_123-happyReduction_123 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn66-		 (([mj AnnSafe happy_var_1],True)-	)}--happyReduce_124 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_124 = happySpecReduce_0  50# happyReduction_124-happyReduction_124  =  happyIn66-		 (([],False)-	)--happyReduce_125 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_125 = happyMonadReduce 1# 51# happyReduction_125-happyReduction_125 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( do { let { pkgFS = getSTRING happy_var_1 }-                        ; unless (looksLikePackageName (unpackFS pkgFS)) $-                             addError (getLoc happy_var_1) $ vcat [-                             text "Parse error" <> colon <+> quotes (ppr pkgFS),-                             text "Version number or non-alphanumeric" <+>-                             text "character in package name"]-                        ; return ([mj AnnPackageName happy_var_1], Just (StringLiteral (getSTRINGs happy_var_1) pkgFS)) })})-	) (\r -> happyReturn (happyIn67 r))--happyReduce_126 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_126 = happySpecReduce_0  51# happyReduction_126-happyReduction_126  =  happyIn67-		 (([],Nothing)-	)--happyReduce_127 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_127 = happySpecReduce_1  52# happyReduction_127-happyReduction_127 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn68-		 (Just happy_var_1-	)}--happyReduce_128 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_128 = happySpecReduce_0  52# happyReduction_128-happyReduction_128  =  happyIn68-		 (Nothing-	)--happyReduce_129 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_129 = happySpecReduce_2  53# happyReduction_129-happyReduction_129 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> -	happyIn69-		 (([mj AnnAs happy_var_1]-                                                 ,sLL happy_var_1 happy_var_2 (Just happy_var_2))-	)}}--happyReduce_130 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_130 = happySpecReduce_0  53# happyReduction_130-happyReduction_130  =  happyIn69-		 (([],noLoc Nothing)-	)--happyReduce_131 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_131 = happyMonadReduce 1# 54# happyReduction_131-happyReduction_131 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut71 happy_x_1 of { (HappyWrap71 happy_var_1) -> -	( let (b, ie) = unLoc happy_var_1 in-                                       checkImportSpec ie-                                        >>= \checkedIe ->-                                          return (L (gl happy_var_1) (Just (b, checkedIe))))})-	) (\r -> happyReturn (happyIn70 r))--happyReduce_132 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_132 = happySpecReduce_0  54# happyReduction_132-happyReduction_132  =  happyIn70-		 (noLoc Nothing-	)--happyReduce_133 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_133 = happyMonadReduce 3# 55# happyReduction_133-happyReduction_133 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (False,-                                                      sLL happy_var_1 happy_var_3 $ fromOL happy_var_2))-                                                   [mop happy_var_1,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn71 r))--happyReduce_134 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_134 = happyMonadReduce 4# 55# happyReduction_134-happyReduction_134 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut49 happy_x_3 of { (HappyWrap49 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( ams (sLL happy_var_1 happy_var_4 (True,-                                                      sLL happy_var_1 happy_var_4 $ fromOL happy_var_3))-                                               [mj AnnHiding happy_var_1,mop happy_var_2,mcp happy_var_4])}}}})-	) (\r -> happyReturn (happyIn71 r))--happyReduce_135 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_135 = happySpecReduce_0  56# happyReduction_135-happyReduction_135  =  happyIn72-		 (noLoc (NoSourceText,9)-	)--happyReduce_136 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_136 = happySpecReduce_1  56# happyReduction_136-happyReduction_136 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn72-		 (sL1 happy_var_1 (getINTEGERs happy_var_1,fromInteger (il_value (getINTEGER happy_var_1)))-	)}--happyReduce_137 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_137 = happySpecReduce_1  57# happyReduction_137-happyReduction_137 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn73-		 (sL1 happy_var_1 InfixN-	)}--happyReduce_138 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_138 = happySpecReduce_1  57# happyReduction_138-happyReduction_138 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn73-		 (sL1 happy_var_1 InfixL-	)}--happyReduce_139 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_139 = happySpecReduce_1  57# happyReduction_139-happyReduction_139 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn73-		 (sL1 happy_var_1 InfixR-	)}--happyReduce_140 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_140 = happyMonadReduce 3# 58# happyReduction_140-happyReduction_140 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut291 happy_x_3 of { (HappyWrap291 happy_var_3) -> -	( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>-                              return (sLL happy_var_1 happy_var_3 ((unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})-	) (\r -> happyReturn (happyIn74 r))--happyReduce_141 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_141 = happySpecReduce_1  58# happyReduction_141-happyReduction_141 happy_x_1-	 =  case happyOut291 happy_x_1 of { (HappyWrap291 happy_var_1) -> -	happyIn74-		 (sL1 happy_var_1 (unitOL happy_var_1)-	)}--happyReduce_142 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_142 = happySpecReduce_2  59# happyReduction_142-happyReduction_142 happy_x_2-	happy_x_1-	 =  case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> -	case happyOut77 happy_x_2 of { (HappyWrap77 happy_var_2) -> -	happyIn75-		 (happy_var_1 `snocOL` happy_var_2-	)}}--happyReduce_143 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_143 = happyMonadReduce 3# 60# happyReduction_143-happyReduction_143 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> -	case happyOut77 happy_x_2 of { (HappyWrap77 happy_var_2) -> -	case happyOut60 happy_x_3 of { (HappyWrap60 happy_var_3) -> -	( ams happy_var_2 happy_var_3 >> return (happy_var_1 `snocOL` happy_var_2))}}})-	) (\r -> happyReturn (happyIn76 r))--happyReduce_144 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_144 = happySpecReduce_0  60# happyReduction_144-happyReduction_144  =  happyIn76-		 (nilOL-	)--happyReduce_145 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_145 = happySpecReduce_1  61# happyReduction_145-happyReduction_145 happy_x_1-	 =  case happyOut78 happy_x_1 of { (HappyWrap78 happy_var_1) -> -	happyIn77-		 (sL1 happy_var_1 (TyClD noExtField (unLoc happy_var_1))-	)}--happyReduce_146 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_146 = happySpecReduce_1  61# happyReduction_146-happyReduction_146 happy_x_1-	 =  case happyOut79 happy_x_1 of { (HappyWrap79 happy_var_1) -> -	happyIn77-		 (sL1 happy_var_1 (TyClD noExtField (unLoc happy_var_1))-	)}--happyReduce_147 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_147 = happySpecReduce_1  61# happyReduction_147-happyReduction_147 happy_x_1-	 =  case happyOut80 happy_x_1 of { (HappyWrap80 happy_var_1) -> -	happyIn77-		 (sL1 happy_var_1 (KindSigD noExtField (unLoc happy_var_1))-	)}--happyReduce_148 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_148 = happySpecReduce_1  61# happyReduction_148-happyReduction_148 happy_x_1-	 =  case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> -	happyIn77-		 (sL1 happy_var_1 (InstD noExtField (unLoc happy_var_1))-	)}--happyReduce_149 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_149 = happySpecReduce_1  61# happyReduction_149-happyReduction_149 happy_x_1-	 =  case happyOut106 happy_x_1 of { (HappyWrap106 happy_var_1) -> -	happyIn77-		 (sLL happy_var_1 happy_var_1 (DerivD noExtField (unLoc happy_var_1))-	)}--happyReduce_150 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_150 = happySpecReduce_1  61# happyReduction_150-happyReduction_150 happy_x_1-	 =  case happyOut107 happy_x_1 of { (HappyWrap107 happy_var_1) -> -	happyIn77-		 (sL1 happy_var_1 (RoleAnnotD noExtField (unLoc happy_var_1))-	)}--happyReduce_151 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_151 = happyMonadReduce 4# 61# happyReduction_151-happyReduction_151 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut173 happy_x_3 of { (HappyWrap173 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( ams (sLL happy_var_1 happy_var_4 (DefD noExtField (DefaultDecl noExtField happy_var_3)))-                                                         [mj AnnDefault happy_var_1-                                                         ,mop happy_var_2,mcp happy_var_4])}}}})-	) (\r -> happyReturn (happyIn77 r))--happyReduce_152 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_152 = happyMonadReduce 2# 61# happyReduction_152-happyReduction_152 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut144 happy_x_2 of { (HappyWrap144 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 (snd $ unLoc happy_var_2))-                                           (mj AnnForeign happy_var_1:(fst $ unLoc happy_var_2)))}})-	) (\r -> happyReturn (happyIn77 r))--happyReduce_153 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_153 = happyMonadReduce 3# 61# happyReduction_153-happyReduction_153 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut139 happy_x_2 of { (HappyWrap139 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ WarningD noExtField (Warnings noExtField (getDEPRECATED_PRAGs happy_var_1) (fromOL happy_var_2)))-                                                       [mo happy_var_1,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn77 r))--happyReduce_154 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_154 = happyMonadReduce 3# 61# happyReduction_154-happyReduction_154 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut137 happy_x_2 of { (HappyWrap137 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ WarningD noExtField (Warnings noExtField (getWARNING_PRAGs happy_var_1) (fromOL happy_var_2)))-                                                       [mo happy_var_1,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn77 r))--happyReduce_155 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_155 = happyMonadReduce 3# 61# happyReduction_155-happyReduction_155 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut129 happy_x_2 of { (HappyWrap129 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ RuleD noExtField (HsRules noExtField (getRULES_PRAGs happy_var_1) (fromOL happy_var_2)))-                                                       [mo happy_var_1,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn77 r))--happyReduce_156 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_156 = happySpecReduce_1  61# happyReduction_156-happyReduction_156 happy_x_1-	 =  case happyOut143 happy_x_1 of { (HappyWrap143 happy_var_1) -> -	happyIn77-		 (happy_var_1-	)}--happyReduce_157 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_157 = happySpecReduce_1  61# happyReduction_157-happyReduction_157 happy_x_1-	 =  case happyOut201 happy_x_1 of { (HappyWrap201 happy_var_1) -> -	happyIn77-		 (happy_var_1-	)}--happyReduce_158 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_158 = happyMonadReduce 1# 61# happyReduction_158-happyReduction_158 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                                   return $ sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1)})-	) (\r -> happyReturn (happyIn77 r))--happyReduce_159 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_159 = happyMonadReduce 4# 62# happyReduction_159-happyReduction_159 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut103 happy_x_2 of { (HappyWrap103 happy_var_2) -> -	case happyOut178 happy_x_3 of { (HappyWrap178 happy_var_3) -> -	case happyOut120 happy_x_4 of { (HappyWrap120 happy_var_4) -> -	( amms (mkClassDecl (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4) happy_var_2 happy_var_3 (snd $ unLoc happy_var_4))-                        (mj AnnClass happy_var_1:(fst $ unLoc happy_var_3)++(fst $ unLoc happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn78 r))--happyReduce_160 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_160 = happyMonadReduce 4# 63# happyReduction_160-happyReduction_160 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut157 happy_x_4 of { (HappyWrap157 happy_var_4) -> -	( amms (mkTySynonym (comb2 happy_var_1 happy_var_4) happy_var_2 happy_var_4)-                        [mj AnnType happy_var_1,mj AnnEqual happy_var_3])}}}})-	) (\r -> happyReturn (happyIn79 r))--happyReduce_161 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_161 = happyMonadReduce 6# 63# happyReduction_161-happyReduction_161 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	case happyOut101 happy_x_4 of { (HappyWrap101 happy_var_4) -> -	case happyOut87 happy_x_5 of { (HappyWrap87 happy_var_5) -> -	case happyOut90 happy_x_6 of { (HappyWrap90 happy_var_6) -> -	( amms (mkFamDecl (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_6) happy_var_3-                                   (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5))-                        (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)-                           ++ (fst $ unLoc happy_var_5) ++ (fst $ unLoc happy_var_6)))}}}}}})-	) (\r -> happyReturn (happyIn79 r))--happyReduce_162 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_162 = happyMonadReduce 5# 63# happyReduction_162-happyReduction_162 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> -	case happyOut105 happy_x_2 of { (HappyWrap105 happy_var_2) -> -	case happyOut103 happy_x_3 of { (HappyWrap103 happy_var_3) -> -	case happyOut187 happy_x_4 of { (HappyWrap187 happy_var_4) -> -	case happyOut195 happy_x_5 of { (HappyWrap195 happy_var_5) -> -	( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3-                           Nothing (reverse (snd $ unLoc happy_var_4))-                                   (fmap reverse happy_var_5))-                                   -- We need the location on tycl_hdr in case-                                   -- constrs and deriving are both empty-                        ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})-	) (\r -> happyReturn (happyIn79 r))--happyReduce_163 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_163 = happyMonadReduce 6# 63# happyReduction_163-happyReduction_163 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> -	case happyOut105 happy_x_2 of { (HappyWrap105 happy_var_2) -> -	case happyOut103 happy_x_3 of { (HappyWrap103 happy_var_3) -> -	case happyOut99 happy_x_4 of { (HappyWrap99 happy_var_4) -> -	case happyOut183 happy_x_5 of { (HappyWrap183 happy_var_5) -> -	case happyOut195 happy_x_6 of { (HappyWrap195 happy_var_6) -> -	( amms (mkTyData (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3-                            (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)-                            (fmap reverse happy_var_6) )-                                   -- We need the location on tycl_hdr in case-                                   -- constrs and deriving are both empty-                    ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})-	) (\r -> happyReturn (happyIn79 r))--happyReduce_164 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_164 = happyMonadReduce 4# 63# happyReduction_164-happyReduction_164 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	case happyOut100 happy_x_4 of { (HappyWrap100 happy_var_4) -> -	( amms (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_4) DataFamily happy_var_3-                                   (snd $ unLoc happy_var_4) Nothing)-                        (mj AnnData happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn79 r))--happyReduce_165 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_165 = happyMonadReduce 4# 64# happyReduction_165-happyReduction_165 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut81 happy_x_2 of { (HappyWrap81 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut157 happy_x_4 of { (HappyWrap157 happy_var_4) -> -	( amms (mkStandaloneKindSig (comb2 happy_var_1 happy_var_4) happy_var_2 happy_var_4)-              [mj AnnType happy_var_1,mu AnnDcolon happy_var_3])}}}})-	) (\r -> happyReturn (happyIn80 r))--happyReduce_166 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_166 = happyMonadReduce 3# 65# happyReduction_166-happyReduction_166 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut81 happy_x_1 of { (HappyWrap81 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut283 happy_x_3 of { (HappyWrap283 happy_var_3) -> -	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>-         return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})-	) (\r -> happyReturn (happyIn81 r))--happyReduce_167 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_167 = happySpecReduce_1  65# happyReduction_167-happyReduction_167 happy_x_1-	 =  case happyOut283 happy_x_1 of { (HappyWrap283 happy_var_1) -> -	happyIn81-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_168 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_168 = happyMonadReduce 4# 66# happyReduction_168-happyReduction_168 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut83 happy_x_2 of { (HappyWrap83 happy_var_2) -> -	case happyOut171 happy_x_3 of { (HappyWrap171 happy_var_3) -> -	case happyOut124 happy_x_4 of { (HappyWrap124 happy_var_4) -> -	( do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc happy_var_4)-             ; let cid = ClsInstDecl { cid_ext = noExtField-                                     , cid_poly_ty = happy_var_3, cid_binds = binds-                                     , cid_sigs = mkClassOpSigs sigs-                                     , cid_tyfam_insts = ats-                                     , cid_overlap_mode = happy_var_2-                                     , cid_datafam_insts = adts }-             ; ams (L (comb3 happy_var_1 (hsSigType happy_var_3) happy_var_4) (ClsInstD { cid_d_ext = noExtField, cid_inst = cid }))-                   (mj AnnInstance happy_var_1 : (fst $ unLoc happy_var_4)) })}}}})-	) (\r -> happyReturn (happyIn82 r))--happyReduce_169 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_169 = happyMonadReduce 3# 66# happyReduction_169-happyReduction_169 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> -	( ams happy_var_3 (fst $ unLoc happy_var_3)-                >> amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))-                    (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn82 r))--happyReduce_170 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_170 = happyMonadReduce 6# 66# happyReduction_170-happyReduction_170 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> -	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> -	case happyOut187 happy_x_5 of { (HappyWrap187 happy_var_5) -> -	case happyOut195 happy_x_6 of { (HappyWrap195 happy_var_6) -> -	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 (snd $ unLoc happy_var_4)-                                      Nothing (reverse (snd  $ unLoc happy_var_5))-                                              (fmap reverse happy_var_6))-                    ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})-	) (\r -> happyReturn (happyIn82 r))--happyReduce_171 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_171 = happyMonadReduce 7# 66# happyReduction_171-happyReduction_171 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> -	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> -	case happyOut99 happy_x_5 of { (HappyWrap99 happy_var_5) -> -	case happyOut183 happy_x_6 of { (HappyWrap183 happy_var_6) -> -	case happyOut195 happy_x_7 of { (HappyWrap195 happy_var_7) -> -	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3 (snd $ unLoc happy_var_4)-                                   (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)-                                   (fmap reverse happy_var_7))-                    ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2-                       :(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})-	) (\r -> happyReturn (happyIn82 r))--happyReduce_172 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_172 = happyMonadReduce 2# 67# happyReduction_172-happyReduction_172 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ajs (sLL happy_var_1 happy_var_2 (Overlappable (getOVERLAPPABLE_PRAGs happy_var_1)))-                                       [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn83 r))--happyReduce_173 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_173 = happyMonadReduce 2# 67# happyReduction_173-happyReduction_173 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ajs (sLL happy_var_1 happy_var_2 (Overlapping (getOVERLAPPING_PRAGs happy_var_1)))-                                       [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn83 r))--happyReduce_174 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_174 = happyMonadReduce 2# 67# happyReduction_174-happyReduction_174 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ajs (sLL happy_var_1 happy_var_2 (Overlaps (getOVERLAPS_PRAGs happy_var_1)))-                                       [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn83 r))--happyReduce_175 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_175 = happyMonadReduce 2# 67# happyReduction_175-happyReduction_175 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ajs (sLL happy_var_1 happy_var_2 (Incoherent (getINCOHERENT_PRAGs happy_var_1)))-                                       [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn83 r))--happyReduce_176 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_176 = happySpecReduce_0  67# happyReduction_176-happyReduction_176  =  happyIn83-		 (Nothing-	)--happyReduce_177 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_177 = happyMonadReduce 1# 68# happyReduction_177-happyReduction_177 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( ams (sL1 happy_var_1 StockStrategy)-                                       [mj AnnStock happy_var_1])})-	) (\r -> happyReturn (happyIn84 r))--happyReduce_178 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_178 = happyMonadReduce 1# 68# happyReduction_178-happyReduction_178 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( ams (sL1 happy_var_1 AnyclassStrategy)-                                       [mj AnnAnyclass happy_var_1])})-	) (\r -> happyReturn (happyIn84 r))--happyReduce_179 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_179 = happyMonadReduce 1# 68# happyReduction_179-happyReduction_179 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( ams (sL1 happy_var_1 NewtypeStrategy)-                                       [mj AnnNewtype happy_var_1])})-	) (\r -> happyReturn (happyIn84 r))--happyReduce_180 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_180 = happyMonadReduce 2# 69# happyReduction_180-happyReduction_180 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 (ViaStrategy (mkLHsSigType happy_var_2)))-                                            [mj AnnVia happy_var_1])}})-	) (\r -> happyReturn (happyIn85 r))--happyReduce_181 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_181 = happyMonadReduce 1# 70# happyReduction_181-happyReduction_181 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( ajs (sL1 happy_var_1 StockStrategy)-                                       [mj AnnStock happy_var_1])})-	) (\r -> happyReturn (happyIn86 r))--happyReduce_182 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_182 = happyMonadReduce 1# 70# happyReduction_182-happyReduction_182 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( ajs (sL1 happy_var_1 AnyclassStrategy)-                                       [mj AnnAnyclass happy_var_1])})-	) (\r -> happyReturn (happyIn86 r))--happyReduce_183 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_183 = happyMonadReduce 1# 70# happyReduction_183-happyReduction_183 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( ajs (sL1 happy_var_1 NewtypeStrategy)-                                       [mj AnnNewtype happy_var_1])})-	) (\r -> happyReturn (happyIn86 r))--happyReduce_184 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_184 = happySpecReduce_1  70# happyReduction_184-happyReduction_184 happy_x_1-	 =  case happyOut85 happy_x_1 of { (HappyWrap85 happy_var_1) -> -	happyIn86-		 (Just happy_var_1-	)}--happyReduce_185 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_185 = happySpecReduce_0  70# happyReduction_185-happyReduction_185  =  happyIn86-		 (Nothing-	)--happyReduce_186 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_186 = happySpecReduce_0  71# happyReduction_186-happyReduction_186  =  happyIn87-		 (noLoc ([], Nothing)-	)--happyReduce_187 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_187 = happySpecReduce_2  71# happyReduction_187-happyReduction_187 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut88 happy_x_2 of { (HappyWrap88 happy_var_2) -> -	happyIn87-		 (sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]-                                                , Just (happy_var_2))-	)}}--happyReduce_188 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_188 = happyMonadReduce 3# 72# happyReduction_188-happyReduction_188 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut89 happy_x_3 of { (HappyWrap89 happy_var_3) -> -	( ams (sLL happy_var_1 happy_var_3 (InjectivityAnn happy_var_1 (reverse (unLoc happy_var_3))))-                  [mu AnnRarrow happy_var_2])}}})-	) (\r -> happyReturn (happyIn88 r))--happyReduce_189 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_189 = happySpecReduce_2  73# happyReduction_189-happyReduction_189 happy_x_2-	happy_x_1-	 =  case happyOut89 happy_x_1 of { (HappyWrap89 happy_var_1) -> -	case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> -	happyIn89-		 (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)-	)}}--happyReduce_190 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_190 = happySpecReduce_1  73# happyReduction_190-happyReduction_190 happy_x_1-	 =  case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> -	happyIn89-		 (sLL happy_var_1 happy_var_1 [happy_var_1]-	)}--happyReduce_191 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_191 = happySpecReduce_0  74# happyReduction_191-happyReduction_191  =  happyIn90-		 (noLoc ([],OpenTypeFamily)-	)--happyReduce_192 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_192 = happySpecReduce_2  74# happyReduction_192-happyReduction_192 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut91 happy_x_2 of { (HappyWrap91 happy_var_2) -> -	happyIn90-		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)-                    ,ClosedTypeFamily (fmap reverse $ snd $ unLoc happy_var_2))-	)}}--happyReduce_193 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_193 = happySpecReduce_3  75# happyReduction_193-happyReduction_193 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut92 happy_x_2 of { (HappyWrap92 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn91-		 (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]-                                                ,Just (unLoc happy_var_2))-	)}}}--happyReduce_194 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_194 = happySpecReduce_3  75# happyReduction_194-happyReduction_194 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut92 happy_x_2 of { (HappyWrap92 happy_var_2) -> -	happyIn91-		 (let (L loc _) = happy_var_2 in-                                             L loc ([],Just (unLoc happy_var_2))-	)}--happyReduce_195 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_195 = happySpecReduce_3  75# happyReduction_195-happyReduction_195 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn91-		 (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mj AnnDotdot happy_var_2-                                                 ,mcc happy_var_3],Nothing)-	)}}}--happyReduce_196 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_196 = happySpecReduce_3  75# happyReduction_196-happyReduction_196 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn91-		 (let (L loc _) = happy_var_2 in-                                             L loc ([mj AnnDotdot happy_var_2],Nothing)-	)}--happyReduce_197 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_197 = happyMonadReduce 3# 76# happyReduction_197-happyReduction_197 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut92 happy_x_1 of { (HappyWrap92 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> -	( let (L loc (anns, eqn)) = happy_var_3 in-                                         asl (unLoc happy_var_1) happy_var_2 (L loc eqn)-                                         >> ams happy_var_3 anns-                                         >> return (sLL happy_var_1 happy_var_3 (L loc eqn : unLoc happy_var_1)))}}})-	) (\r -> happyReturn (happyIn92 r))--happyReduce_198 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_198 = happyMonadReduce 2# 76# happyReduction_198-happyReduction_198 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut92 happy_x_1 of { (HappyWrap92 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)-                                         >> return (sLL happy_var_1 happy_var_2  (unLoc happy_var_1)))}})-	) (\r -> happyReturn (happyIn92 r))--happyReduce_199 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_199 = happyMonadReduce 1# 76# happyReduction_199-happyReduction_199 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut93 happy_x_1 of { (HappyWrap93 happy_var_1) -> -	( let (L loc (anns, eqn)) = happy_var_1 in-                                         ams happy_var_1 anns-                                         >> return (sLL happy_var_1 happy_var_1 [L loc eqn]))})-	) (\r -> happyReturn (happyIn92 r))--happyReduce_200 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_200 = happySpecReduce_0  76# happyReduction_200-happyReduction_200  =  happyIn92-		 (noLoc []-	)--happyReduce_201 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_201 = happyMonadReduce 6# 77# happyReduction_201-happyReduction_201 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut162 happy_x_4 of { (HappyWrap162 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	case happyOut156 happy_x_6 of { (HappyWrap156 happy_var_6) -> -	( do { hintExplicitForall happy_var_1-                    ; (eqn,ann) <- mkTyFamInstEqn (Just happy_var_2) happy_var_4 happy_var_6-                    ; return (sLL happy_var_1 happy_var_6-                               (mu AnnForall happy_var_1:mj AnnDot happy_var_3:mj AnnEqual happy_var_5:ann,eqn)) })}}}}}})-	) (\r -> happyReturn (happyIn93 r))--happyReduce_202 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_202 = happyMonadReduce 3# 77# happyReduction_202-happyReduction_202 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut156 happy_x_3 of { (HappyWrap156 happy_var_3) -> -	( do { (eqn,ann) <- mkTyFamInstEqn Nothing happy_var_1 happy_var_3-                    ; return (sLL happy_var_1 happy_var_3 (mj AnnEqual happy_var_2:ann, eqn))  })}}})-	) (\r -> happyReturn (happyIn93 r))--happyReduce_203 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_203 = happyMonadReduce 4# 78# happyReduction_203-happyReduction_203 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut95 happy_x_2 of { (HappyWrap95 happy_var_2) -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	case happyOut100 happy_x_4 of { (HappyWrap100 happy_var_4) -> -	( amms (liftM mkTyClD (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) DataFamily happy_var_3-                                                  (snd $ unLoc happy_var_4) Nothing))-                        (mj AnnData happy_var_1:happy_var_2++(fst $ unLoc happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn94 r))--happyReduce_204 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_204 = happyMonadReduce 3# 78# happyReduction_204-happyReduction_204 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> -	case happyOut102 happy_x_3 of { (HappyWrap102 happy_var_3) -> -	( amms (liftM mkTyClD-                        (mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_3) OpenTypeFamily happy_var_2-                                   (fst . snd $ unLoc happy_var_3)-                                   (snd . snd $ unLoc happy_var_3)))-                       (mj AnnType happy_var_1:(fst $ unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn94 r))--happyReduce_205 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_205 = happyMonadReduce 4# 78# happyReduction_205-happyReduction_205 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	case happyOut102 happy_x_4 of { (HappyWrap102 happy_var_4) -> -	( amms (liftM mkTyClD-                        (mkFamDecl (comb3 happy_var_1 happy_var_3 happy_var_4) OpenTypeFamily happy_var_3-                                   (fst . snd $ unLoc happy_var_4)-                                   (snd . snd $ unLoc happy_var_4)))-                       (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn94 r))--happyReduce_206 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_206 = happyMonadReduce 2# 78# happyReduction_206-happyReduction_206 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut93 happy_x_2 of { (HappyWrap93 happy_var_2) -> -	( ams happy_var_2 (fst $ unLoc happy_var_2) >>-                   amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_2) (snd $ unLoc happy_var_2)))-                        (mj AnnType happy_var_1:(fst $ unLoc happy_var_2)))}})-	) (\r -> happyReturn (happyIn94 r))--happyReduce_207 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_207 = happyMonadReduce 3# 78# happyReduction_207-happyReduction_207 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> -	( ams happy_var_3 (fst $ unLoc happy_var_3) >>-                   amms (liftM mkInstD (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3)))-                        (mj AnnType happy_var_1:mj AnnInstance happy_var_2:(fst $ unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn94 r))--happyReduce_208 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_208 = happySpecReduce_0  79# happyReduction_208-happyReduction_208  =  happyIn95-		 ([]-	)--happyReduce_209 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_209 = happySpecReduce_1  79# happyReduction_209-happyReduction_209 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn95-		 ([mj AnnFamily happy_var_1]-	)}--happyReduce_210 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_210 = happySpecReduce_0  80# happyReduction_210-happyReduction_210  =  happyIn96-		 ([]-	)--happyReduce_211 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_211 = happySpecReduce_1  80# happyReduction_211-happyReduction_211 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn96-		 ([mj AnnInstance happy_var_1]-	)}--happyReduce_212 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_212 = happyMonadReduce 3# 81# happyReduction_212-happyReduction_212 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> -	case happyOut93 happy_x_3 of { (HappyWrap93 happy_var_3) -> -	( ams happy_var_3 (fst $ unLoc happy_var_3) >>-                   amms (mkTyFamInst (comb2 happy_var_1 happy_var_3) (snd $ unLoc happy_var_3))-                        (mj AnnType happy_var_1:happy_var_2++(fst $ unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn97 r))--happyReduce_213 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_213 = happyMonadReduce 6# 81# happyReduction_213-happyReduction_213 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> -	case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> -	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> -	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> -	case happyOut187 happy_x_5 of { (HappyWrap187 happy_var_5) -> -	case happyOut195 happy_x_6 of { (HappyWrap195 happy_var_6) -> -	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 (snd $ unLoc happy_var_4)-                                    Nothing (reverse (snd $ unLoc happy_var_5))-                                            (fmap reverse happy_var_6))-                       ((fst $ unLoc happy_var_1):happy_var_2++(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})-	) (\r -> happyReturn (happyIn97 r))--happyReduce_214 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_214 = happyMonadReduce 7# 81# happyReduction_214-happyReduction_214 (happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> -	case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> -	case happyOut105 happy_x_3 of { (HappyWrap105 happy_var_3) -> -	case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> -	case happyOut99 happy_x_5 of { (HappyWrap99 happy_var_5) -> -	case happyOut183 happy_x_6 of { (HappyWrap183 happy_var_6) -> -	case happyOut195 happy_x_7 of { (HappyWrap195 happy_var_7) -> -	( amms (mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3-                                (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)-                                (fmap reverse happy_var_7))-                        ((fst $ unLoc happy_var_1):happy_var_2++(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})-	) (\r -> happyReturn (happyIn97 r))--happyReduce_215 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_215 = happySpecReduce_1  82# happyReduction_215-happyReduction_215 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn98-		 (sL1 happy_var_1 (mj AnnData    happy_var_1,DataType)-	)}--happyReduce_216 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_216 = happySpecReduce_1  82# happyReduction_216-happyReduction_216 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn98-		 (sL1 happy_var_1 (mj AnnNewtype happy_var_1,NewType)-	)}--happyReduce_217 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_217 = happySpecReduce_0  83# happyReduction_217-happyReduction_217  =  happyIn99-		 (noLoc     ([]               , Nothing)-	)--happyReduce_218 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_218 = happySpecReduce_2  83# happyReduction_218-happyReduction_218 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> -	happyIn99-		 (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], Just happy_var_2)-	)}}--happyReduce_219 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_219 = happySpecReduce_0  84# happyReduction_219-happyReduction_219  =  happyIn100-		 (noLoc     ([]               , noLoc (NoSig noExtField)         )-	)--happyReduce_220 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_220 = happySpecReduce_2  84# happyReduction_220-happyReduction_220 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> -	happyIn100-		 (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig noExtField happy_var_2))-	)}}--happyReduce_221 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_221 = happySpecReduce_0  85# happyReduction_221-happyReduction_221  =  happyIn101-		 (noLoc     ([]               , noLoc     (NoSig    noExtField)   )-	)--happyReduce_222 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_222 = happySpecReduce_2  85# happyReduction_222-happyReduction_222 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> -	happyIn101-		 (sLL happy_var_1 happy_var_2 ([mu AnnDcolon happy_var_1], sLL happy_var_1 happy_var_2 (KindSig  noExtField happy_var_2))-	)}}--happyReduce_223 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_223 = happySpecReduce_2  85# happyReduction_223-happyReduction_223 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut177 happy_x_2 of { (HappyWrap177 happy_var_2) -> -	happyIn101-		 (sLL happy_var_1 happy_var_2 ([mj AnnEqual happy_var_1] , sLL happy_var_1 happy_var_2 (TyVarSig noExtField happy_var_2))-	)}}--happyReduce_224 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_224 = happySpecReduce_0  86# happyReduction_224-happyReduction_224  =  happyIn102-		 (noLoc ([], (noLoc (NoSig noExtField), Nothing))-	)--happyReduce_225 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_225 = happySpecReduce_2  86# happyReduction_225-happyReduction_225 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut182 happy_x_2 of { (HappyWrap182 happy_var_2) -> -	happyIn102-		 (sLL happy_var_1 happy_var_2 ( [mu AnnDcolon happy_var_1]-                                 , (sLL happy_var_2 happy_var_2 (KindSig noExtField happy_var_2), Nothing))-	)}}--happyReduce_226 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_226 = happyReduce 4# 86# happyReduction_226-happyReduction_226 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut177 happy_x_2 of { (HappyWrap177 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut88 happy_x_4 of { (HappyWrap88 happy_var_4) -> -	happyIn102-		 (sLL happy_var_1 happy_var_4 ([mj AnnEqual happy_var_1, mj AnnVbar happy_var_3]-                            , (sLL happy_var_1 happy_var_2 (TyVarSig noExtField happy_var_2), Just happy_var_4))-	) `HappyStk` happyRest}}}}--happyReduce_227 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_227 = happyMonadReduce 3# 87# happyReduction_227-happyReduction_227 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)-                                       >> (return (sLL happy_var_1 happy_var_3 (Just happy_var_1, happy_var_3))))}}})-	) (\r -> happyReturn (happyIn103 r))--happyReduce_228 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_228 = happySpecReduce_1  87# happyReduction_228-happyReduction_228 happy_x_1-	 =  case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> -	happyIn103-		 (sL1 happy_var_1 (Nothing, happy_var_1)-	)}--happyReduce_229 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_229 = happyMonadReduce 6# 88# happyReduction_229-happyReduction_229 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut160 happy_x_4 of { (HappyWrap160 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	case happyOut162 happy_x_6 of { (HappyWrap162 happy_var_6) -> -	( hintExplicitForall happy_var_1-                                                       >> (addAnnotation (gl happy_var_4) (toUnicodeAnn AnnDarrow happy_var_5) (gl happy_var_5)-                                                           >> return (sLL happy_var_1 happy_var_6 ([mu AnnForall happy_var_1, mj AnnDot happy_var_3]-                                                                                , (Just happy_var_4, Just happy_var_2, happy_var_6)))-                                                          ))}}}}}})-	) (\r -> happyReturn (happyIn104 r))--happyReduce_230 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_230 = happyMonadReduce 4# 88# happyReduction_230-happyReduction_230 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut162 happy_x_4 of { (HappyWrap162 happy_var_4) -> -	( hintExplicitForall happy_var_1-                                          >> return (sLL happy_var_1 happy_var_4 ([mu AnnForall happy_var_1, mj AnnDot happy_var_3]-                                                               , (Nothing, Just happy_var_2, happy_var_4))))}}}})-	) (\r -> happyReturn (happyIn104 r))--happyReduce_231 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_231 = happyMonadReduce 3# 88# happyReduction_231-happyReduction_231 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)-                                       >> (return (sLL happy_var_1 happy_var_3([], (Just happy_var_1, Nothing, happy_var_3)))))}}})-	) (\r -> happyReturn (happyIn104 r))--happyReduce_232 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_232 = happySpecReduce_1  88# happyReduction_232-happyReduction_232 happy_x_1-	 =  case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> -	happyIn104-		 (sL1 happy_var_1 ([], (Nothing, Nothing, happy_var_1))-	)}--happyReduce_233 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_233 = happyMonadReduce 4# 89# happyReduction_233-happyReduction_233 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( ajs (sLL happy_var_1 happy_var_4 (CType (getCTYPEs happy_var_1) (Just (Header (getSTRINGs happy_var_2) (getSTRING happy_var_2)))-                                        (getSTRINGs happy_var_3,getSTRING happy_var_3)))-                              [mo happy_var_1,mj AnnHeader happy_var_2,mj AnnVal happy_var_3,mc happy_var_4])}}}})-	) (\r -> happyReturn (happyIn105 r))--happyReduce_234 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_234 = happyMonadReduce 3# 89# happyReduction_234-happyReduction_234 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ajs (sLL happy_var_1 happy_var_3 (CType (getCTYPEs happy_var_1) Nothing (getSTRINGs happy_var_2, getSTRING happy_var_2)))-                              [mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn105 r))--happyReduce_235 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_235 = happySpecReduce_0  89# happyReduction_235-happyReduction_235  =  happyIn105-		 (Nothing-	)--happyReduce_236 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_236 = happyMonadReduce 5# 90# happyReduction_236-happyReduction_236 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut86 happy_x_2 of { (HappyWrap86 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut83 happy_x_4 of { (HappyWrap83 happy_var_4) -> -	case happyOut171 happy_x_5 of { (HappyWrap171 happy_var_5) -> -	( do { let { err = text "in the stand-alone deriving instance"-                                    <> colon <+> quotes (ppr happy_var_5) }-                      ; ams (sLL happy_var_1 (hsSigType happy_var_5)-                                 (DerivDecl noExtField (mkHsWildCardBndrs happy_var_5) happy_var_2 happy_var_4))-                            [mj AnnDeriving happy_var_1, mj AnnInstance happy_var_3] })}}}}})-	) (\r -> happyReturn (happyIn106 r))--happyReduce_237 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_237 = happyMonadReduce 4# 91# happyReduction_237-happyReduction_237 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut283 happy_x_3 of { (HappyWrap283 happy_var_3) -> -	case happyOut108 happy_x_4 of { (HappyWrap108 happy_var_4) -> -	( amms (mkRoleAnnotDecl (comb3 happy_var_1 happy_var_3 happy_var_4) happy_var_3 (reverse (unLoc happy_var_4)))-                  [mj AnnType happy_var_1,mj AnnRole happy_var_2])}}}})-	) (\r -> happyReturn (happyIn107 r))--happyReduce_238 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_238 = happySpecReduce_0  92# happyReduction_238-happyReduction_238  =  happyIn108-		 (noLoc []-	)--happyReduce_239 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_239 = happySpecReduce_1  92# happyReduction_239-happyReduction_239 happy_x_1-	 =  case happyOut109 happy_x_1 of { (HappyWrap109 happy_var_1) -> -	happyIn108-		 (happy_var_1-	)}--happyReduce_240 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_240 = happySpecReduce_1  93# happyReduction_240-happyReduction_240 happy_x_1-	 =  case happyOut110 happy_x_1 of { (HappyWrap110 happy_var_1) -> -	happyIn109-		 (sLL happy_var_1 happy_var_1 [happy_var_1]-	)}--happyReduce_241 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_241 = happySpecReduce_2  93# happyReduction_241-happyReduction_241 happy_x_2-	happy_x_1-	 =  case happyOut109 happy_x_1 of { (HappyWrap109 happy_var_1) -> -	case happyOut110 happy_x_2 of { (HappyWrap110 happy_var_2) -> -	happyIn109-		 (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1-	)}}--happyReduce_242 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_242 = happySpecReduce_1  94# happyReduction_242-happyReduction_242 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn110-		 (sL1 happy_var_1 $ Just $ getVARID happy_var_1-	)}--happyReduce_243 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_243 = happySpecReduce_1  94# happyReduction_243-happyReduction_243 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn110-		 (sL1 happy_var_1 Nothing-	)}--happyReduce_244 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_244 = happyMonadReduce 4# 95# happyReduction_244-happyReduction_244 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut112 happy_x_2 of { (HappyWrap112 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut248 happy_x_4 of { (HappyWrap248 happy_var_4) -> -	(      let (name, args,as ) = happy_var_2 in-                 ams (sLL happy_var_1 happy_var_4 . ValD noExtField $ mkPatSynBind name args happy_var_4-                                                    ImplicitBidirectional)-               (as ++ [mj AnnPattern happy_var_1, mj AnnEqual happy_var_3]))}}}})-	) (\r -> happyReturn (happyIn111 r))--happyReduce_245 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_245 = happyMonadReduce 4# 95# happyReduction_245-happyReduction_245 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut112 happy_x_2 of { (HappyWrap112 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut248 happy_x_4 of { (HappyWrap248 happy_var_4) -> -	(    let (name, args, as) = happy_var_2 in-               ams (sLL happy_var_1 happy_var_4 . ValD noExtField $ mkPatSynBind name args happy_var_4 Unidirectional)-               (as ++ [mj AnnPattern happy_var_1,mu AnnLarrow happy_var_3]))}}}})-	) (\r -> happyReturn (happyIn111 r))--happyReduce_246 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_246 = happyMonadReduce 5# 95# happyReduction_246-happyReduction_246 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut112 happy_x_2 of { (HappyWrap112 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut248 happy_x_4 of { (HappyWrap248 happy_var_4) -> -	case happyOut115 happy_x_5 of { (HappyWrap115 happy_var_5) -> -	( do { let (name, args, as) = happy_var_2-                  ; mg <- mkPatSynMatchGroup name (snd $ unLoc happy_var_5)-                  ; ams (sLL happy_var_1 happy_var_5 . ValD noExtField $-                           mkPatSynBind name args happy_var_4 (ExplicitBidirectional mg))-                       (as ++ ((mj AnnPattern happy_var_1:mu AnnLarrow happy_var_3:(fst $ unLoc happy_var_5))) )-                   })}}}}})-	) (\r -> happyReturn (happyIn111 r))--happyReduce_247 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_247 = happySpecReduce_2  96# happyReduction_247-happyReduction_247 happy_x_2-	happy_x_1-	 =  case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> -	case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> -	happyIn112-		 ((happy_var_1, PrefixCon happy_var_2, [])-	)}}--happyReduce_248 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_248 = happySpecReduce_3  96# happyReduction_248-happyReduction_248 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> -	case happyOut279 happy_x_2 of { (HappyWrap279 happy_var_2) -> -	case happyOut304 happy_x_3 of { (HappyWrap304 happy_var_3) -> -	happyIn112-		 ((happy_var_2, InfixCon happy_var_1 happy_var_3, [])-	)}}}--happyReduce_249 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_249 = happyReduce 4# 96# happyReduction_249-happyReduction_249 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut114 happy_x_3 of { (HappyWrap114 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn112-		 ((happy_var_1, RecCon happy_var_3, [moc happy_var_2, mcc happy_var_4] )-	) `HappyStk` happyRest}}}}--happyReduce_250 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_250 = happySpecReduce_0  97# happyReduction_250-happyReduction_250  =  happyIn113-		 ([]-	)--happyReduce_251 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_251 = happySpecReduce_2  97# happyReduction_251-happyReduction_251 happy_x_2-	happy_x_1-	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> -	case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> -	happyIn113-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_252 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_252 = happySpecReduce_1  98# happyReduction_252-happyReduction_252 happy_x_1-	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> -	happyIn114-		 ([RecordPatSynField happy_var_1 happy_var_1]-	)}--happyReduce_253 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_253 = happyMonadReduce 3# 98# happyReduction_253-happyReduction_253 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut114 happy_x_3 of { (HappyWrap114 happy_var_3) -> -	( addAnnotation (getLoc happy_var_1) AnnComma (getLoc happy_var_2) >>-                                         return ((RecordPatSynField happy_var_1 happy_var_1) : happy_var_3 ))}}})-	) (\r -> happyReturn (happyIn114 r))--happyReduce_254 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_254 = happyReduce 4# 99# happyReduction_254-happyReduction_254 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut125 happy_x_3 of { (HappyWrap125 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn115-		 (sLL happy_var_1 happy_var_4 ((mj AnnWhere happy_var_1:moc happy_var_2-                                           :mcc happy_var_4:(fst $ unLoc happy_var_3)),sL1 happy_var_3 (snd $ unLoc happy_var_3))-	) `HappyStk` happyRest}}}}--happyReduce_255 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_255 = happyReduce 4# 99# happyReduction_255-happyReduction_255 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut125 happy_x_3 of { (HappyWrap125 happy_var_3) -> -	happyIn115-		 (L (comb2 happy_var_1 happy_var_3) ((mj AnnWhere happy_var_1:(fst $ unLoc happy_var_3))-                                          ,sL1 happy_var_3 (snd $ unLoc happy_var_3))-	) `HappyStk` happyRest}}--happyReduce_256 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_256 = happyMonadReduce 4# 100# happyReduction_256-happyReduction_256 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut276 happy_x_2 of { (HappyWrap276 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut151 happy_x_4 of { (HappyWrap151 happy_var_4) -> -	( ams (sLL happy_var_1 happy_var_4 $ PatSynSig noExtField (unLoc happy_var_2) (mkLHsSigType happy_var_4))-                          [mj AnnPattern happy_var_1, mu AnnDcolon happy_var_3])}}}})-	) (\r -> happyReturn (happyIn116 r))--happyReduce_257 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_257 = happySpecReduce_1  101# happyReduction_257-happyReduction_257 happy_x_1-	 =  case happyOut94 happy_x_1 of { (HappyWrap94 happy_var_1) -> -	happyIn117-		 (happy_var_1-	)}--happyReduce_258 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_258 = happySpecReduce_1  101# happyReduction_258-happyReduction_258 happy_x_1-	 =  case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> -	happyIn117-		 (happy_var_1-	)}--happyReduce_259 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_259 = happyMonadReduce 4# 101# happyReduction_259-happyReduction_259 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut211 happy_x_2 of { (HappyWrap211 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut151 happy_x_4 of { (HappyWrap151 happy_var_4) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                       do { v <- checkValSigLhs happy_var_2-                          ; let err = text "in default signature" <> colon <+>-                                      quotes (ppr happy_var_2)-                          ; ams (sLL happy_var_1 happy_var_4 $ SigD noExtField $ ClassOpSig noExtField True [v] $ mkLHsSigType happy_var_4)-                                [mj AnnDefault happy_var_1,mu AnnDcolon happy_var_3] })}}}})-	) (\r -> happyReturn (happyIn117 r))--happyReduce_260 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_260 = happyMonadReduce 3# 102# happyReduction_260-happyReduction_260 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut118 happy_x_1 of { (HappyWrap118 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut117 happy_x_3 of { (HappyWrap117 happy_var_3) -> -	( if isNilOL (snd $ unLoc happy_var_1)-                                             then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                                    , unitOL happy_var_3))-                                             else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]-                                           >> return (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1-                                                                ,(snd $ unLoc happy_var_1) `appOL` unitOL happy_var_3)))}}})-	) (\r -> happyReturn (happyIn118 r))--happyReduce_261 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_261 = happyMonadReduce 2# 102# happyReduction_261-happyReduction_261 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut118 happy_x_1 of { (HappyWrap118 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( if isNilOL (snd $ unLoc happy_var_1)-                                             then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                                                   ,snd $ unLoc happy_var_1))-                                             else ams (lastOL (snd $ unLoc happy_var_1)) [mj AnnSemi happy_var_2]-                                           >> return (sLL happy_var_1 happy_var_2  (unLoc happy_var_1)))}})-	) (\r -> happyReturn (happyIn118 r))--happyReduce_262 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_262 = happySpecReduce_1  102# happyReduction_262-happyReduction_262 happy_x_1-	 =  case happyOut117 happy_x_1 of { (HappyWrap117 happy_var_1) -> -	happyIn118-		 (sL1 happy_var_1 ([], unitOL happy_var_1)-	)}--happyReduce_263 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_263 = happySpecReduce_0  102# happyReduction_263-happyReduction_263  =  happyIn118-		 (noLoc ([],nilOL)-	)--happyReduce_264 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_264 = happySpecReduce_3  103# happyReduction_264-happyReduction_264 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut118 happy_x_2 of { (HappyWrap118 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn119-		 (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)-                                             ,snd $ unLoc happy_var_2)-	)}}}--happyReduce_265 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_265 = happySpecReduce_3  103# happyReduction_265-happyReduction_265 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut118 happy_x_2 of { (HappyWrap118 happy_var_2) -> -	happyIn119-		 (happy_var_2-	)}--happyReduce_266 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_266 = happySpecReduce_2  104# happyReduction_266-happyReduction_266 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut119 happy_x_2 of { (HappyWrap119 happy_var_2) -> -	happyIn120-		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)-                                             ,snd $ unLoc happy_var_2)-	)}}--happyReduce_267 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_267 = happySpecReduce_0  104# happyReduction_267-happyReduction_267  =  happyIn120-		 (noLoc ([],nilOL)-	)--happyReduce_268 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_268 = happySpecReduce_1  105# happyReduction_268-happyReduction_268 happy_x_1-	 =  case happyOut97 happy_x_1 of { (HappyWrap97 happy_var_1) -> -	happyIn121-		 (sLL happy_var_1 happy_var_1 (unitOL (sL1 happy_var_1 (InstD noExtField (unLoc happy_var_1))))-	)}--happyReduce_269 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_269 = happySpecReduce_1  105# happyReduction_269-happyReduction_269 happy_x_1-	 =  case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> -	happyIn121-		 (sLL happy_var_1 happy_var_1 (unitOL happy_var_1)-	)}--happyReduce_270 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_270 = happyMonadReduce 3# 106# happyReduction_270-happyReduction_270 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut122 happy_x_1 of { (HappyWrap122 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut121 happy_x_3 of { (HappyWrap121 happy_var_3) -> -	( if isNilOL (snd $ unLoc happy_var_1)-                                             then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                                    , unLoc happy_var_3))-                                             else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]-                                           >> return-                                            (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1-                                                       ,(snd $ unLoc happy_var_1) `appOL` unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn122 r))--happyReduce_271 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_271 = happyMonadReduce 2# 106# happyReduction_271-happyReduction_271 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut122 happy_x_1 of { (HappyWrap122 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( if isNilOL (snd $ unLoc happy_var_1)-                                             then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                                                   ,snd $ unLoc happy_var_1))-                                             else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]-                                           >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})-	) (\r -> happyReturn (happyIn122 r))--happyReduce_272 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_272 = happySpecReduce_1  106# happyReduction_272-happyReduction_272 happy_x_1-	 =  case happyOut121 happy_x_1 of { (HappyWrap121 happy_var_1) -> -	happyIn122-		 (sL1 happy_var_1 ([],unLoc happy_var_1)-	)}--happyReduce_273 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_273 = happySpecReduce_0  106# happyReduction_273-happyReduction_273  =  happyIn122-		 (noLoc ([],nilOL)-	)--happyReduce_274 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_274 = happySpecReduce_3  107# happyReduction_274-happyReduction_274 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut122 happy_x_2 of { (HappyWrap122 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn123-		 (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2),snd $ unLoc happy_var_2)-	)}}}--happyReduce_275 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_275 = happySpecReduce_3  107# happyReduction_275-happyReduction_275 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut122 happy_x_2 of { (HappyWrap122 happy_var_2) -> -	happyIn123-		 (L (gl happy_var_2) (unLoc happy_var_2)-	)}--happyReduce_276 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_276 = happySpecReduce_2  108# happyReduction_276-happyReduction_276 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut123 happy_x_2 of { (HappyWrap123 happy_var_2) -> -	happyIn124-		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)-                                             ,(snd $ unLoc happy_var_2))-	)}}--happyReduce_277 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_277 = happySpecReduce_0  108# happyReduction_277-happyReduction_277  =  happyIn124-		 (noLoc ([],nilOL)-	)--happyReduce_278 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_278 = happyMonadReduce 3# 109# happyReduction_278-happyReduction_278 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut125 happy_x_1 of { (HappyWrap125 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut202 happy_x_3 of { (HappyWrap202 happy_var_3) -> -	( if isNilOL (snd $ unLoc happy_var_1)-                                 then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                        , unitOL happy_var_3))-                                 else do ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]-                                           >> return (-                                          let { this = unitOL happy_var_3;-                                                rest = snd $ unLoc happy_var_1;-                                                these = rest `appOL` this }-                                          in rest `seq` this `seq` these `seq`-                                             (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,these))))}}})-	) (\r -> happyReturn (happyIn125 r))--happyReduce_279 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_279 = happyMonadReduce 2# 109# happyReduction_279-happyReduction_279 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut125 happy_x_1 of { (HappyWrap125 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( if isNilOL (snd $ unLoc happy_var_1)-                                  then return (sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                          ,snd $ unLoc happy_var_1)))-                                  else ams (lastOL $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]-                                           >> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})-	) (\r -> happyReturn (happyIn125 r))--happyReduce_280 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_280 = happySpecReduce_1  109# happyReduction_280-happyReduction_280 happy_x_1-	 =  case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> -	happyIn125-		 (sL1 happy_var_1 ([], unitOL happy_var_1)-	)}--happyReduce_281 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_281 = happySpecReduce_0  109# happyReduction_281-happyReduction_281  =  happyIn125-		 (noLoc ([],nilOL)-	)--happyReduce_282 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_282 = happySpecReduce_3  110# happyReduction_282-happyReduction_282 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut125 happy_x_2 of { (HappyWrap125 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn126-		 (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)-                                                   ,sL1 happy_var_2 $ snd $ unLoc happy_var_2)-	)}}}--happyReduce_283 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_283 = happySpecReduce_3  110# happyReduction_283-happyReduction_283 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut125 happy_x_2 of { (HappyWrap125 happy_var_2) -> -	happyIn126-		 (L (gl happy_var_2) (fst $ unLoc happy_var_2,sL1 happy_var_2 $ snd $ unLoc happy_var_2)-	)}--happyReduce_284 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_284 = happyMonadReduce 1# 111# happyReduction_284-happyReduction_284 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut126 happy_x_1 of { (HappyWrap126 happy_var_1) -> -	( do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc happy_var_1)-                                  ; return (sL1 happy_var_1 (fst $ unLoc happy_var_1-                                                    ,sL1 happy_var_1 $ HsValBinds noExtField val_binds)) })})-	) (\r -> happyReturn (happyIn127 r))--happyReduce_285 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_285 = happySpecReduce_3  111# happyReduction_285-happyReduction_285 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut261 happy_x_2 of { (HappyWrap261 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn127-		 (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]-                                             ,sL1 happy_var_2 $ HsIPBinds noExtField (IPBinds noExtField (reverse $ unLoc happy_var_2)))-	)}}}--happyReduce_286 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_286 = happySpecReduce_3  111# happyReduction_286-happyReduction_286 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut261 happy_x_2 of { (HappyWrap261 happy_var_2) -> -	happyIn127-		 (L (getLoc happy_var_2) ([]-                                            ,sL1 happy_var_2 $ HsIPBinds noExtField (IPBinds noExtField (reverse $ unLoc happy_var_2)))-	)}--happyReduce_287 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_287 = happySpecReduce_2  112# happyReduction_287-happyReduction_287 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> -	happyIn128-		 (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1 : (fst $ unLoc happy_var_2)-                                             ,snd $ unLoc happy_var_2)-	)}}--happyReduce_288 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_288 = happySpecReduce_0  112# happyReduction_288-happyReduction_288  =  happyIn128-		 (noLoc ([],noLoc emptyLocalBinds)-	)--happyReduce_289 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_289 = happyMonadReduce 3# 113# happyReduction_289-happyReduction_289 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut129 happy_x_1 of { (HappyWrap129 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut130 happy_x_3 of { (HappyWrap130 happy_var_3) -> -	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)-                                          >> return (happy_var_1 `snocOL` happy_var_3))}}})-	) (\r -> happyReturn (happyIn129 r))--happyReduce_290 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_290 = happyMonadReduce 2# 113# happyReduction_290-happyReduction_290 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut129 happy_x_1 of { (HappyWrap129 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)-                                          >> return happy_var_1)}})-	) (\r -> happyReturn (happyIn129 r))--happyReduce_291 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_291 = happySpecReduce_1  113# happyReduction_291-happyReduction_291 happy_x_1-	 =  case happyOut130 happy_x_1 of { (HappyWrap130 happy_var_1) -> -	happyIn129-		 (unitOL happy_var_1-	)}--happyReduce_292 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_292 = happySpecReduce_0  113# happyReduction_292-happyReduction_292  =  happyIn129-		 (nilOL-	)--happyReduce_293 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_293 = happyMonadReduce 6# 114# happyReduction_293-happyReduction_293 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut131 happy_x_2 of { (HappyWrap131 happy_var_2) -> -	case happyOut134 happy_x_3 of { (HappyWrap134 happy_var_3) -> -	case happyOut211 happy_x_4 of { (HappyWrap211 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	case happyOut210 happy_x_6 of { (HappyWrap210 happy_var_6) -> -	(runECP_P happy_var_4 >>= \ happy_var_4 ->-           runECP_P happy_var_6 >>= \ happy_var_6 ->-           ams (sLL happy_var_1 happy_var_6 $ HsRule { rd_ext = noExtField-                                   , rd_name = L (gl happy_var_1) (getSTRINGs happy_var_1, getSTRING happy_var_1)-                                   , rd_act = (snd happy_var_2) `orElse` AlwaysActive-                                   , rd_tyvs = sndOf3 happy_var_3, rd_tmvs = thdOf3 happy_var_3-                                   , rd_lhs = happy_var_4, rd_rhs = happy_var_6 })-               (mj AnnEqual happy_var_5 : (fst happy_var_2) ++ (fstOf3 happy_var_3)))}}}}}})-	) (\r -> happyReturn (happyIn130 r))--happyReduce_294 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_294 = happySpecReduce_0  115# happyReduction_294-happyReduction_294  =  happyIn131-		 (([],Nothing)-	)--happyReduce_295 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_295 = happySpecReduce_1  115# happyReduction_295-happyReduction_295 happy_x_1-	 =  case happyOut133 happy_x_1 of { (HappyWrap133 happy_var_1) -> -	happyIn131-		 ((fst happy_var_1,Just (snd happy_var_1))-	)}--happyReduce_296 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_296 = happySpecReduce_1  116# happyReduction_296-happyReduction_296 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn132-		 ([mj AnnTilde happy_var_1]-	)}--happyReduce_297 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_297 = happyMonadReduce 1# 116# happyReduction_297-happyReduction_297 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( if (getVARSYM happy_var_1 == fsLit "~")-                   then return [mj AnnTilde happy_var_1]-                   else do { addError (getLoc happy_var_1) $ text "Invalid rule activation marker"-                           ; return [] })})-	) (\r -> happyReturn (happyIn132 r))--happyReduce_298 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_298 = happySpecReduce_3  117# happyReduction_298-happyReduction_298 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn133-		 (([mos happy_var_1,mj AnnVal happy_var_2,mcs happy_var_3]-                                  ,ActiveAfter  (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))-	)}}}--happyReduce_299 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_299 = happyReduce 4# 117# happyReduction_299-happyReduction_299 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn133-		 ((happy_var_2++[mos happy_var_1,mj AnnVal happy_var_3,mcs happy_var_4]-                                  ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))-	) `HappyStk` happyRest}}}}--happyReduce_300 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_300 = happySpecReduce_3  117# happyReduction_300-happyReduction_300 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn133-		 ((happy_var_2++[mos happy_var_1,mcs happy_var_3]-                                  ,NeverActive)-	)}}}--happyReduce_301 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_301 = happyMonadReduce 6# 118# happyReduction_301-happyReduction_301 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut135 happy_x_5 of { (HappyWrap135 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	( let tyvs = mkRuleTyVarBndrs happy_var_2-                                                              in hintExplicitForall happy_var_1-                                                              >> checkRuleTyVarBndrNames (mkRuleTyVarBndrs happy_var_2)-                                                              >> return ([mu AnnForall happy_var_1,mj AnnDot happy_var_3,-                                                                          mu AnnForall happy_var_4,mj AnnDot happy_var_6],-                                                                         Just (mkRuleTyVarBndrs happy_var_2), mkRuleBndrs happy_var_5))}}}}}})-	) (\r -> happyReturn (happyIn134 r))--happyReduce_302 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_302 = happySpecReduce_3  118# happyReduction_302-happyReduction_302 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn134-		 (([mu AnnForall happy_var_1,mj AnnDot happy_var_3],-                                                              Nothing, mkRuleBndrs happy_var_2)-	)}}}--happyReduce_303 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_303 = happySpecReduce_0  118# happyReduction_303-happyReduction_303  =  happyIn134-		 (([], Nothing, [])-	)--happyReduce_304 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_304 = happySpecReduce_2  119# happyReduction_304-happyReduction_304 happy_x_2-	happy_x_1-	 =  case happyOut136 happy_x_1 of { (HappyWrap136 happy_var_1) -> -	case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> -	happyIn135-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_305 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_305 = happySpecReduce_0  119# happyReduction_305-happyReduction_305  =  happyIn135-		 ([]-	)--happyReduce_306 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_306 = happySpecReduce_1  120# happyReduction_306-happyReduction_306 happy_x_1-	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> -	happyIn136-		 (sLL happy_var_1 happy_var_1 (RuleTyTmVar happy_var_1 Nothing)-	)}--happyReduce_307 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_307 = happyMonadReduce 5# 120# happyReduction_307-happyReduction_307 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut304 happy_x_2 of { (HappyWrap304 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	( ams (sLL happy_var_1 happy_var_5 (RuleTyTmVar happy_var_2 (Just happy_var_4)))-                                               [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5])}}}}})-	) (\r -> happyReturn (happyIn136 r))--happyReduce_308 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_308 = happyMonadReduce 3# 121# happyReduction_308-happyReduction_308 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut137 happy_x_1 of { (HappyWrap137 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut138 happy_x_3 of { (HappyWrap138 happy_var_3) -> -	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)-                                          >> return (happy_var_1 `appOL` happy_var_3))}}})-	) (\r -> happyReturn (happyIn137 r))--happyReduce_309 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_309 = happyMonadReduce 2# 121# happyReduction_309-happyReduction_309 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut137 happy_x_1 of { (HappyWrap137 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)-                                          >> return happy_var_1)}})-	) (\r -> happyReturn (happyIn137 r))--happyReduce_310 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_310 = happySpecReduce_1  121# happyReduction_310-happyReduction_310 happy_x_1-	 =  case happyOut138 happy_x_1 of { (HappyWrap138 happy_var_1) -> -	happyIn137-		 (happy_var_1-	)}--happyReduce_311 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_311 = happySpecReduce_0  121# happyReduction_311-happyReduction_311  =  happyIn137-		 (nilOL-	)--happyReduce_312 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_312 = happyMonadReduce 2# 122# happyReduction_312-happyReduction_312 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut270 happy_x_1 of { (HappyWrap270 happy_var_1) -> -	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> -	( amsu (sLL happy_var_1 happy_var_2 (Warning noExtField (unLoc happy_var_1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))-                     (fst $ unLoc happy_var_2))}})-	) (\r -> happyReturn (happyIn138 r))--happyReduce_313 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_313 = happyMonadReduce 3# 123# happyReduction_313-happyReduction_313 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut139 happy_x_1 of { (HappyWrap139 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut140 happy_x_3 of { (HappyWrap140 happy_var_3) -> -	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)-                                          >> return (happy_var_1 `appOL` happy_var_3))}}})-	) (\r -> happyReturn (happyIn139 r))--happyReduce_314 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_314 = happyMonadReduce 2# 123# happyReduction_314-happyReduction_314 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut139 happy_x_1 of { (HappyWrap139 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( addAnnotation (oll happy_var_1) AnnSemi (gl happy_var_2)-                                          >> return happy_var_1)}})-	) (\r -> happyReturn (happyIn139 r))--happyReduce_315 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_315 = happySpecReduce_1  123# happyReduction_315-happyReduction_315 happy_x_1-	 =  case happyOut140 happy_x_1 of { (HappyWrap140 happy_var_1) -> -	happyIn139-		 (happy_var_1-	)}--happyReduce_316 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_316 = happySpecReduce_0  123# happyReduction_316-happyReduction_316  =  happyIn139-		 (nilOL-	)--happyReduce_317 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_317 = happyMonadReduce 2# 124# happyReduction_317-happyReduction_317 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut270 happy_x_1 of { (HappyWrap270 happy_var_1) -> -	case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> -	( amsu (sLL happy_var_1 happy_var_2 $ (Warning noExtField (unLoc happy_var_1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2)))-                     (fst $ unLoc happy_var_2))}})-	) (\r -> happyReturn (happyIn140 r))--happyReduce_318 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_318 = happySpecReduce_1  125# happyReduction_318-happyReduction_318 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn141-		 (sL1 happy_var_1 ([],[L (gl happy_var_1) (getStringLiteral happy_var_1)])-	)}--happyReduce_319 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_319 = happySpecReduce_3  125# happyReduction_319-happyReduction_319 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut142 happy_x_2 of { (HappyWrap142 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn141-		 (sLL happy_var_1 happy_var_3 $ ([mos happy_var_1,mcs happy_var_3],fromOL (unLoc happy_var_2))-	)}}}--happyReduce_320 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_320 = happyMonadReduce 3# 126# happyReduction_320-happyReduction_320 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut142 happy_x_1 of { (HappyWrap142 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( addAnnotation (oll $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>-                               return (sLL happy_var_1 happy_var_3 (unLoc happy_var_1 `snocOL`-                                                  (L (gl happy_var_3) (getStringLiteral happy_var_3)))))}}})-	) (\r -> happyReturn (happyIn142 r))--happyReduce_321 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_321 = happySpecReduce_1  126# happyReduction_321-happyReduction_321 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn142-		 (sLL happy_var_1 happy_var_1 (unitOL (L (gl happy_var_1) (getStringLiteral happy_var_1)))-	)}--happyReduce_322 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_322 = happySpecReduce_0  126# happyReduction_322-happyReduction_322  =  happyIn142-		 (noLoc nilOL-	)--happyReduce_323 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_323 = happyMonadReduce 4# 127# happyReduction_323-happyReduction_323 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut271 happy_x_2 of { (HappyWrap271 happy_var_2) -> -	case happyOut217 happy_x_3 of { (HappyWrap217 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( runECP_P happy_var_3 >>= \ happy_var_3 ->-                                            ams (sLL happy_var_1 happy_var_4 (AnnD noExtField $ HsAnnotation noExtField-                                            (getANN_PRAGs happy_var_1)-                                            (ValueAnnProvenance happy_var_2) happy_var_3))-                                            [mo happy_var_1,mc happy_var_4])}}}})-	) (\r -> happyReturn (happyIn143 r))--happyReduce_324 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_324 = happyMonadReduce 5# 127# happyReduction_324-happyReduction_324 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut288 happy_x_3 of { (HappyWrap288 happy_var_3) -> -	case happyOut217 happy_x_4 of { (HappyWrap217 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	( runECP_P happy_var_4 >>= \ happy_var_4 ->-                                            ams (sLL happy_var_1 happy_var_5 (AnnD noExtField $ HsAnnotation noExtField-                                            (getANN_PRAGs happy_var_1)-                                            (TypeAnnProvenance happy_var_3) happy_var_4))-                                            [mo happy_var_1,mj AnnType happy_var_2,mc happy_var_5])}}}}})-	) (\r -> happyReturn (happyIn143 r))--happyReduce_325 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_325 = happyMonadReduce 4# 127# happyReduction_325-happyReduction_325 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut217 happy_x_3 of { (HappyWrap217 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( runECP_P happy_var_3 >>= \ happy_var_3 ->-                                            ams (sLL happy_var_1 happy_var_4 (AnnD noExtField $ HsAnnotation noExtField-                                                (getANN_PRAGs happy_var_1)-                                                 ModuleAnnProvenance happy_var_3))-                                                [mo happy_var_1,mj AnnModule happy_var_2,mc happy_var_4])}}}})-	) (\r -> happyReturn (happyIn143 r))--happyReduce_326 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_326 = happyMonadReduce 4# 128# happyReduction_326-happyReduction_326 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut145 happy_x_2 of { (HappyWrap145 happy_var_2) -> -	case happyOut146 happy_x_3 of { (HappyWrap146 happy_var_3) -> -	case happyOut147 happy_x_4 of { (HappyWrap147 happy_var_4) -> -	( mkImport happy_var_2 happy_var_3 (snd $ unLoc happy_var_4) >>= \i ->-                 return (sLL happy_var_1 happy_var_4 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_4),i)))}}}})-	) (\r -> happyReturn (happyIn144 r))--happyReduce_327 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_327 = happyMonadReduce 3# 128# happyReduction_327-happyReduction_327 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut145 happy_x_2 of { (HappyWrap145 happy_var_2) -> -	case happyOut147 happy_x_3 of { (HappyWrap147 happy_var_3) -> -	( do { d <- mkImport happy_var_2 (noLoc PlaySafe) (snd $ unLoc happy_var_3);-                    return (sLL happy_var_1 happy_var_3 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_3),d)) })}}})-	) (\r -> happyReturn (happyIn144 r))--happyReduce_328 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_328 = happyMonadReduce 3# 128# happyReduction_328-happyReduction_328 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut145 happy_x_2 of { (HappyWrap145 happy_var_2) -> -	case happyOut147 happy_x_3 of { (HappyWrap147 happy_var_3) -> -	( mkExport happy_var_2 (snd $ unLoc happy_var_3) >>= \i ->-                  return (sLL happy_var_1 happy_var_3 (mj AnnExport happy_var_1 : (fst $ unLoc happy_var_3),i) ))}}})-	) (\r -> happyReturn (happyIn144 r))--happyReduce_329 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_329 = happySpecReduce_1  129# happyReduction_329-happyReduction_329 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn145-		 (sLL happy_var_1 happy_var_1 StdCallConv-	)}--happyReduce_330 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_330 = happySpecReduce_1  129# happyReduction_330-happyReduction_330 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn145-		 (sLL happy_var_1 happy_var_1 CCallConv-	)}--happyReduce_331 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_331 = happySpecReduce_1  129# happyReduction_331-happyReduction_331 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn145-		 (sLL happy_var_1 happy_var_1 CApiConv-	)}--happyReduce_332 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_332 = happySpecReduce_1  129# happyReduction_332-happyReduction_332 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn145-		 (sLL happy_var_1 happy_var_1 PrimCallConv-	)}--happyReduce_333 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_333 = happySpecReduce_1  129# happyReduction_333-happyReduction_333 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn145-		 (sLL happy_var_1 happy_var_1 JavaScriptCallConv-	)}--happyReduce_334 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_334 = happySpecReduce_1  130# happyReduction_334-happyReduction_334 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn146-		 (sLL happy_var_1 happy_var_1 PlayRisky-	)}--happyReduce_335 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_335 = happySpecReduce_1  130# happyReduction_335-happyReduction_335 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn146-		 (sLL happy_var_1 happy_var_1 PlaySafe-	)}--happyReduce_336 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_336 = happySpecReduce_1  130# happyReduction_336-happyReduction_336 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn146-		 (sLL happy_var_1 happy_var_1 PlayInterruptible-	)}--happyReduce_337 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_337 = happyReduce 4# 131# happyReduction_337-happyReduction_337 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut301 happy_x_2 of { (HappyWrap301 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut151 happy_x_4 of { (HappyWrap151 happy_var_4) -> -	happyIn147-		 (sLL happy_var_1 happy_var_4 ([mu AnnDcolon happy_var_3]-                                             ,(L (getLoc happy_var_1)-                                                    (getStringLiteral happy_var_1), happy_var_2, mkLHsSigType happy_var_4))-	) `HappyStk` happyRest}}}}--happyReduce_338 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_338 = happySpecReduce_3  131# happyReduction_338-happyReduction_338 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> -	happyIn147-		 (sLL happy_var_1 happy_var_3 ([mu AnnDcolon happy_var_2]-                                             ,(noLoc (StringLiteral NoSourceText nilFS), happy_var_1, mkLHsSigType happy_var_3))-	)}}}--happyReduce_339 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_339 = happySpecReduce_0  132# happyReduction_339-happyReduction_339  =  happyIn148-		 (([],Nothing)-	)--happyReduce_340 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_340 = happySpecReduce_2  132# happyReduction_340-happyReduction_340 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut150 happy_x_2 of { (HappyWrap150 happy_var_2) -> -	happyIn148-		 (([mu AnnDcolon happy_var_1],Just happy_var_2)-	)}}--happyReduce_341 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_341 = happySpecReduce_0  133# happyReduction_341-happyReduction_341  =  happyIn149-		 (([], Nothing)-	)--happyReduce_342 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_342 = happySpecReduce_2  133# happyReduction_342-happyReduction_342 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut281 happy_x_2 of { (HappyWrap281 happy_var_2) -> -	happyIn149-		 (([mu AnnDcolon happy_var_1], Just happy_var_2)-	)}}--happyReduce_343 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_343 = happySpecReduce_1  134# happyReduction_343-happyReduction_343 happy_x_1-	 =  case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> -	happyIn150-		 (happy_var_1-	)}--happyReduce_344 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_344 = happySpecReduce_1  135# happyReduction_344-happyReduction_344 happy_x_1-	 =  case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> -	happyIn151-		 (happy_var_1-	)}--happyReduce_345 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_345 = happyMonadReduce 3# 136# happyReduction_345-happyReduction_345 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut152 happy_x_1 of { (HappyWrap152 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut301 happy_x_3 of { (HappyWrap301 happy_var_3) -> -	( addAnnotation (gl $ head $ unLoc happy_var_1)-                                                       AnnComma (gl happy_var_2)-                                         >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})-	) (\r -> happyReturn (happyIn152 r))--happyReduce_346 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_346 = happySpecReduce_1  136# happyReduction_346-happyReduction_346 happy_x_1-	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> -	happyIn152-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_347 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_347 = happySpecReduce_1  137# happyReduction_347-happyReduction_347 happy_x_1-	 =  case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> -	happyIn153-		 (unitOL (mkLHsSigType happy_var_1)-	)}--happyReduce_348 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_348 = happyMonadReduce 3# 137# happyReduction_348-happyReduction_348 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut153 happy_x_3 of { (HappyWrap153 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)-                                >> return (unitOL (mkLHsSigType happy_var_1) `appOL` happy_var_3))}}})-	) (\r -> happyReturn (happyIn153 r))--happyReduce_349 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_349 = happySpecReduce_2  138# happyReduction_349-happyReduction_349 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn154-		 (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getUNPACK_PRAGs happy_var_1, SrcUnpack)-	)}}--happyReduce_350 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_350 = happySpecReduce_2  138# happyReduction_350-happyReduction_350 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn154-		 (sLL happy_var_1 happy_var_2 ([mo happy_var_1, mc happy_var_2], getNOUNPACK_PRAGs happy_var_1, SrcNoUnpack)-	)}}--happyReduce_351 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_351 = happySpecReduce_1  139# happyReduction_351-happyReduction_351 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn155-		 ((mj AnnDot happy_var_1,    ForallInvis)-	)}--happyReduce_352 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_352 = happySpecReduce_1  139# happyReduction_352-happyReduction_352 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn155-		 ((mu AnnRarrow happy_var_1, ForallVis)-	)}--happyReduce_353 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_353 = happySpecReduce_1  140# happyReduction_353-happyReduction_353 happy_x_1-	 =  case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> -	happyIn156-		 (happy_var_1-	)}--happyReduce_354 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_354 = happyMonadReduce 3# 140# happyReduction_354-happyReduction_354 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut182 happy_x_3 of { (HappyWrap182 happy_var_3) -> -	( ams (sLL happy_var_1 happy_var_3 $ HsKindSig noExtField happy_var_1 happy_var_3)-                                      [mu AnnDcolon happy_var_2])}}})-	) (\r -> happyReturn (happyIn156 r))--happyReduce_355 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_355 = happySpecReduce_1  141# happyReduction_355-happyReduction_355 happy_x_1-	 =  case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> -	happyIn157-		 (happy_var_1-	)}--happyReduce_356 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_356 = happyMonadReduce 3# 141# happyReduction_356-happyReduction_356 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut182 happy_x_3 of { (HappyWrap182 happy_var_3) -> -	( ams (sLL happy_var_1 happy_var_3 $ HsKindSig noExtField happy_var_1 happy_var_3)-                                      [mu AnnDcolon happy_var_2])}}})-	) (\r -> happyReturn (happyIn157 r))--happyReduce_357 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_357 = happyMonadReduce 4# 142# happyReduction_357-happyReduction_357 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	case happyOut155 happy_x_3 of { (HappyWrap155 happy_var_3) -> -	case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> -	( let (fv_ann, fv_flag) = happy_var_3 in-                                           hintExplicitForall happy_var_1 *>-                                           ams (sLL happy_var_1 happy_var_4 $-                                                HsForAllTy { hst_fvf = fv_flag-                                                           , hst_bndrs = happy_var_2-                                                           , hst_xforall = noExtField-                                                           , hst_body = happy_var_4 })-                                               [mu AnnForall happy_var_1,fv_ann])}}}})-	) (\r -> happyReturn (happyIn158 r))--happyReduce_358 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_358 = happyMonadReduce 3# 142# happyReduction_358-happyReduction_358 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> -	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)-                                         >> return (sLL happy_var_1 happy_var_3 $-                                            HsQualTy { hst_ctxt = happy_var_1-                                                     , hst_xqual = noExtField-                                                     , hst_body = happy_var_3 }))}}})-	) (\r -> happyReturn (happyIn158 r))--happyReduce_359 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_359 = happyMonadReduce 3# 142# happyReduction_359-happyReduction_359 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	( ams (sLL happy_var_1 happy_var_3 (HsIParamTy noExtField happy_var_1 happy_var_3))-                                             [mu AnnDcolon happy_var_2])}}})-	) (\r -> happyReturn (happyIn158 r))--happyReduce_360 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_360 = happySpecReduce_1  142# happyReduction_360-happyReduction_360 happy_x_1-	 =  case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> -	happyIn158-		 (happy_var_1-	)}--happyReduce_361 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_361 = happyMonadReduce 4# 143# happyReduction_361-happyReduction_361 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	case happyOut155 happy_x_3 of { (HappyWrap155 happy_var_3) -> -	case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> -	( let (fv_ann, fv_flag) = happy_var_3 in-                                            hintExplicitForall happy_var_1 *>-                                            ams (sLL happy_var_1 happy_var_4 $-                                                 HsForAllTy { hst_fvf = fv_flag-                                                            , hst_bndrs = happy_var_2-                                                            , hst_xforall = noExtField-                                                            , hst_body = happy_var_4 })-                                                [mu AnnForall happy_var_1,fv_ann])}}}})-	) (\r -> happyReturn (happyIn159 r))--happyReduce_362 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_362 = happyMonadReduce 3# 143# happyReduction_362-happyReduction_362 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> -	( addAnnotation (gl happy_var_1) (toUnicodeAnn AnnDarrow happy_var_2) (gl happy_var_2)-                                         >> return (sLL happy_var_1 happy_var_3 $-                                            HsQualTy { hst_ctxt = happy_var_1-                                                     , hst_xqual = noExtField-                                                     , hst_body = happy_var_3 }))}}})-	) (\r -> happyReturn (happyIn159 r))--happyReduce_363 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_363 = happyMonadReduce 3# 143# happyReduction_363-happyReduction_363 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut162 happy_x_3 of { (HappyWrap162 happy_var_3) -> -	( ams (sLL happy_var_1 happy_var_3 (HsIParamTy noExtField happy_var_1 happy_var_3))-                                             [mu AnnDcolon happy_var_2])}}})-	) (\r -> happyReturn (happyIn159 r))--happyReduce_364 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_364 = happySpecReduce_1  143# happyReduction_364-happyReduction_364 happy_x_1-	 =  case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> -	happyIn159-		 (happy_var_1-	)}--happyReduce_365 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_365 = happyMonadReduce 1# 144# happyReduction_365-happyReduction_365 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	( do { (anns,ctx) <- checkContext happy_var_1-                                                ; if null (unLoc ctx)-                                                   then addAnnotation (gl happy_var_1) AnnUnit (gl happy_var_1)-                                                   else return ()-                                                ; ams ctx anns-                                                })})-	) (\r -> happyReturn (happyIn160 r))--happyReduce_366 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_366 = happyMonadReduce 1# 145# happyReduction_366-happyReduction_366 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut164 happy_x_1 of { (HappyWrap164 happy_var_1) -> -	( do { (anns,ctx) <- checkContext happy_var_1-                                                ; if null (unLoc ctx)-                                                   then addAnnotation (gl happy_var_1) AnnUnit (gl happy_var_1)-                                                   else return ()-                                                ; ams ctx anns-                                                })})-	) (\r -> happyReturn (happyIn161 r))--happyReduce_367 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_367 = happySpecReduce_1  146# happyReduction_367-happyReduction_367 happy_x_1-	 =  case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	happyIn162-		 (happy_var_1-	)}--happyReduce_368 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_368 = happyMonadReduce 3# 146# happyReduction_368-happyReduction_368 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> -	( ams happy_var_1 [mu AnnRarrow happy_var_2] -- See note [GADT decl discards annotations]-                                       >> ams (sLL happy_var_1 happy_var_3 $ HsFunTy noExtField happy_var_1 happy_var_3)-                                              [mu AnnRarrow happy_var_2])}}})-	) (\r -> happyReturn (happyIn162 r))--happyReduce_369 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_369 = happySpecReduce_1  147# happyReduction_369-happyReduction_369 happy_x_1-	 =  case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	happyIn163-		 (happy_var_1-	)}--happyReduce_370 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_370 = happySpecReduce_2  147# happyReduction_370-happyReduction_370 happy_x_2-	happy_x_1-	 =  case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	case happyOut323 happy_x_2 of { (HappyWrap323 happy_var_2) -> -	happyIn163-		 (sLL happy_var_1 happy_var_2 $ HsDocTy noExtField happy_var_1 happy_var_2-	)}}--happyReduce_371 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_371 = happySpecReduce_2  147# happyReduction_371-happyReduction_371 happy_x_2-	happy_x_1-	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> -	case happyOut167 happy_x_2 of { (HappyWrap167 happy_var_2) -> -	happyIn163-		 (sLL happy_var_1 happy_var_2 $ HsDocTy noExtField happy_var_2 happy_var_1-	)}}--happyReduce_372 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_372 = happyMonadReduce 3# 147# happyReduction_372-happyReduction_372 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> -	( ams happy_var_1 [mu AnnRarrow happy_var_2] -- See note [GADT decl discards annotations]-                                         >> ams (sLL happy_var_1 happy_var_3 $ HsFunTy noExtField happy_var_1 happy_var_3)-                                                [mu AnnRarrow happy_var_2])}}})-	) (\r -> happyReturn (happyIn163 r))--happyReduce_373 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_373 = happyMonadReduce 4# 147# happyReduction_373-happyReduction_373 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> -	case happyOut323 happy_x_2 of { (HappyWrap323 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> -	( ams happy_var_1 [mu AnnRarrow happy_var_3] -- See note [GADT decl discards annotations]-                                         >> ams (sLL happy_var_1 happy_var_4 $-                                                 HsFunTy noExtField (L (comb2 happy_var_1 happy_var_2)-                                                            (HsDocTy noExtField happy_var_1 happy_var_2))-                                                         happy_var_4)-                                                [mu AnnRarrow happy_var_3])}}}})-	) (\r -> happyReturn (happyIn163 r))--happyReduce_374 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_374 = happyMonadReduce 4# 147# happyReduction_374-happyReduction_374 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> -	case happyOut167 happy_x_2 of { (HappyWrap167 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> -	( ams happy_var_2 [mu AnnRarrow happy_var_3] -- See note [GADT decl discards annotations]-                                         >> ams (sLL happy_var_1 happy_var_4 $-                                                 HsFunTy noExtField (L (comb2 happy_var_1 happy_var_2)-                                                            (HsDocTy noExtField happy_var_2 happy_var_1))-                                                         happy_var_4)-                                                [mu AnnRarrow happy_var_3])}}}})-	) (\r -> happyReturn (happyIn163 r))--happyReduce_375 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_375 = happyMonadReduce 1# 148# happyReduction_375-happyReduction_375 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> -	( mergeOps (unLoc happy_var_1))})-	) (\r -> happyReturn (happyIn164 r))--happyReduce_376 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_376 = happySpecReduce_1  149# happyReduction_376-happyReduction_376 happy_x_1-	 =  case happyOut166 happy_x_1 of { (HappyWrap166 happy_var_1) -> -	happyIn165-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_377 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_377 = happySpecReduce_2  149# happyReduction_377-happyReduction_377 happy_x_2-	happy_x_1-	 =  case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> -	case happyOut166 happy_x_2 of { (HappyWrap166 happy_var_2) -> -	happyIn165-		 (sLL happy_var_1 happy_var_2 $ happy_var_2 : (unLoc happy_var_1)-	)}}--happyReduce_378 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_378 = happySpecReduce_1  150# happyReduction_378-happyReduction_378 happy_x_1-	 =  case happyOut169 happy_x_1 of { (HappyWrap169 happy_var_1) -> -	happyIn166-		 (happy_var_1-	)}--happyReduce_379 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_379 = happySpecReduce_1  150# happyReduction_379-happyReduction_379 happy_x_1-	 =  case happyOut323 happy_x_1 of { (HappyWrap323 happy_var_1) -> -	happyIn166-		 (sL1 happy_var_1 $ TyElDocPrev (unLoc happy_var_1)-	)}--happyReduce_380 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_380 = happyMonadReduce 1# 151# happyReduction_380-happyReduction_380 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> -	( mergeOps happy_var_1)})-	) (\r -> happyReturn (happyIn167 r))--happyReduce_381 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_381 = happySpecReduce_1  152# happyReduction_381-happyReduction_381 happy_x_1-	 =  case happyOut169 happy_x_1 of { (HappyWrap169 happy_var_1) -> -	happyIn168-		 ([happy_var_1]-	)}--happyReduce_382 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_382 = happySpecReduce_2  152# happyReduction_382-happyReduction_382 happy_x_2-	happy_x_1-	 =  case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> -	case happyOut169 happy_x_2 of { (HappyWrap169 happy_var_2) -> -	happyIn168-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_383 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_383 = happySpecReduce_1  153# happyReduction_383-happyReduction_383 happy_x_1-	 =  case happyOut170 happy_x_1 of { (HappyWrap170 happy_var_1) -> -	happyIn169-		 (sL1 happy_var_1 $ TyElOpd (unLoc happy_var_1)-	)}--happyReduce_384 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_384 = happySpecReduce_2  153# happyReduction_384-happyReduction_384 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> -	happyIn169-		 (sLL happy_var_1 happy_var_2 $ (TyElKindApp (comb2 happy_var_1 happy_var_2) happy_var_2)-	)}}--happyReduce_385 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_385 = happySpecReduce_1  153# happyReduction_385-happyReduction_385 happy_x_1-	 =  case happyOut285 happy_x_1 of { (HappyWrap285 happy_var_1) -> -	happyIn169-		 (sL1 happy_var_1 $ TyElOpr (unLoc happy_var_1)-	)}--happyReduce_386 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_386 = happySpecReduce_1  153# happyReduction_386-happyReduction_386 happy_x_1-	 =  case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> -	happyIn169-		 (sL1 happy_var_1 $ TyElOpr (unLoc happy_var_1)-	)}--happyReduce_387 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_387 = happyMonadReduce 2# 153# happyReduction_387-happyReduction_387 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut280 happy_x_2 of { (HappyWrap280 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 $ TyElOpr (unLoc happy_var_2))-                                               [mj AnnSimpleQuote happy_var_1,mj AnnVal happy_var_2])}})-	) (\r -> happyReturn (happyIn169 r))--happyReduce_388 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_388 = happyMonadReduce 2# 153# happyReduction_388-happyReduction_388 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut292 happy_x_2 of { (HappyWrap292 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 $ TyElOpr (unLoc happy_var_2))-                                               [mj AnnSimpleQuote happy_var_1,mj AnnVal happy_var_2])}})-	) (\r -> happyReturn (happyIn169 r))--happyReduce_389 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_389 = happySpecReduce_1  153# happyReduction_389-happyReduction_389 happy_x_1-	 =  case happyOut154 happy_x_1 of { (HappyWrap154 happy_var_1) -> -	happyIn169-		 (sL1 happy_var_1 $ TyElUnpackedness (unLoc happy_var_1)-	)}--happyReduce_390 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_390 = happySpecReduce_1  154# happyReduction_390-happyReduction_390 happy_x_1-	 =  case happyOut282 happy_x_1 of { (HappyWrap282 happy_var_1) -> -	happyIn170-		 (sL1 happy_var_1 (HsTyVar noExtField NotPromoted happy_var_1)-	)}--happyReduce_391 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_391 = happySpecReduce_1  154# happyReduction_391-happyReduction_391 happy_x_1-	 =  case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> -	happyIn170-		 (sL1 happy_var_1 (HsTyVar noExtField NotPromoted happy_var_1)-	)}--happyReduce_392 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_392 = happyMonadReduce 1# 154# happyReduction_392-happyReduction_392 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( do { warnStarIsType (getLoc happy_var_1)-                                               ; return $ sL1 happy_var_1 (HsStarTy noExtField (isUnicode happy_var_1)) })})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_393 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_393 = happyMonadReduce 2# 154# happyReduction_393-happyReduction_393 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 (mkBangTy SrcLazy happy_var_2)) [mj AnnTilde happy_var_1])}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_394 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_394 = happyMonadReduce 2# 154# happyReduction_394-happyReduction_394 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 (mkBangTy SrcStrict happy_var_2)) [mj AnnBang happy_var_1])}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_395 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_395 = happyMonadReduce 3# 154# happyReduction_395-happyReduction_395 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut192 happy_x_2 of { (HappyWrap192 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( amms (checkRecordSyntax-                                                    (sLL happy_var_1 happy_var_3 $ HsRecTy noExtField happy_var_2))-                                                        -- Constructor sigs only-                                                 [moc happy_var_1,mcc happy_var_3])}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_396 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_396 = happyMonadReduce 2# 154# happyReduction_396-happyReduction_396 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy noExtField-                                                    HsBoxedOrConstraintTuple [])-                                                [mop happy_var_1,mcp happy_var_2])}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_397 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_397 = happyMonadReduce 5# 154# happyReduction_397-happyReduction_397 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut174 happy_x_4 of { (HappyWrap174 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	( addAnnotation (gl happy_var_2) AnnComma-                                                          (gl happy_var_3) >>-                                            ams (sLL happy_var_1 happy_var_5 $ HsTupleTy noExtField--                                             HsBoxedOrConstraintTuple (happy_var_2 : happy_var_4))-                                                [mop happy_var_1,mcp happy_var_5])}}}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_398 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_398 = happyMonadReduce 2# 154# happyReduction_398-happyReduction_398 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 $ HsTupleTy noExtField HsUnboxedTuple [])-                                             [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_399 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_399 = happyMonadReduce 3# 154# happyReduction_399-happyReduction_399 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ HsTupleTy noExtField HsUnboxedTuple happy_var_2)-                                             [mo happy_var_1,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_400 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_400 = happyMonadReduce 3# 154# happyReduction_400-happyReduction_400 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut175 happy_x_2 of { (HappyWrap175 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ HsSumTy noExtField happy_var_2)-                                             [mo happy_var_1,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_401 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_401 = happyMonadReduce 3# 154# happyReduction_401-happyReduction_401 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ HsListTy  noExtField happy_var_2) [mos happy_var_1,mcs happy_var_3])}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_402 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_402 = happyMonadReduce 3# 154# happyReduction_402-happyReduction_402 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ HsParTy   noExtField happy_var_2) [mop happy_var_1,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_403 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_403 = happySpecReduce_1  154# happyReduction_403-happyReduction_403 happy_x_1-	 =  case happyOut209 happy_x_1 of { (HappyWrap209 happy_var_1) -> -	happyIn170-		 (mapLoc (HsSpliceTy noExtField) happy_var_1-	)}--happyReduce_404 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_404 = happySpecReduce_1  154# happyReduction_404-happyReduction_404 happy_x_1-	 =  case happyOut221 happy_x_1 of { (HappyWrap221 happy_var_1) -> -	happyIn170-		 (mapLoc (HsSpliceTy noExtField) happy_var_1-	)}--happyReduce_405 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_405 = happyMonadReduce 2# 154# happyReduction_405-happyReduction_405 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut272 happy_x_2 of { (HappyWrap272 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 $ HsTyVar noExtField IsPromoted happy_var_2) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_406 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_406 = happyMonadReduce 6# 154# happyReduction_406-happyReduction_406 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut156 happy_x_3 of { (HappyWrap156 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut174 happy_x_5 of { (HappyWrap174 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	( addAnnotation (gl happy_var_3) AnnComma (gl happy_var_4) >>-                                ams (sLL happy_var_1 happy_var_6 $ HsExplicitTupleTy noExtField (happy_var_3 : happy_var_5))-                                    [mj AnnSimpleQuote happy_var_1,mop happy_var_2,mcp happy_var_6])}}}}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_407 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_407 = happyMonadReduce 4# 154# happyReduction_407-happyReduction_407 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut173 happy_x_3 of { (HappyWrap173 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( ams (sLL happy_var_1 happy_var_4 $ HsExplicitListTy noExtField IsPromoted happy_var_3)-                                                       [mj AnnSimpleQuote happy_var_1,mos happy_var_2,mcs happy_var_4])}}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_408 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_408 = happyMonadReduce 2# 154# happyReduction_408-happyReduction_408 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut301 happy_x_2 of { (HappyWrap301 happy_var_2) -> -	( ams (sLL happy_var_1 happy_var_2 $ HsTyVar noExtField IsPromoted happy_var_2)-                                                       [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_409 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_409 = happyMonadReduce 5# 154# happyReduction_409-happyReduction_409 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut174 happy_x_4 of { (HappyWrap174 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	( addAnnotation (gl happy_var_2) AnnComma-                                                           (gl happy_var_3) >>-                                             ams (sLL happy_var_1 happy_var_5 $ HsExplicitListTy noExtField NotPromoted (happy_var_2 : happy_var_4))-                                                 [mos happy_var_1,mcs happy_var_5])}}}}})-	) (\r -> happyReturn (happyIn170 r))--happyReduce_410 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_410 = happySpecReduce_1  154# happyReduction_410-happyReduction_410 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn170-		 (sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsNumTy (getINTEGERs happy_var_1)-                                                           (il_value (getINTEGER happy_var_1))-	)}--happyReduce_411 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_411 = happySpecReduce_1  154# happyReduction_411-happyReduction_411 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn170-		 (sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsStrTy (getSTRINGs happy_var_1)-                                                                     (getSTRING  happy_var_1)-	)}--happyReduce_412 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_412 = happySpecReduce_1  154# happyReduction_412-happyReduction_412 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn170-		 (sL1 happy_var_1 $ mkAnonWildCardTy-	)}--happyReduce_413 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_413 = happySpecReduce_1  155# happyReduction_413-happyReduction_413 happy_x_1-	 =  case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> -	happyIn171-		 (mkLHsSigType happy_var_1-	)}--happyReduce_414 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_414 = happySpecReduce_1  156# happyReduction_414-happyReduction_414 happy_x_1-	 =  case happyOut157 happy_x_1 of { (HappyWrap157 happy_var_1) -> -	happyIn172-		 ([mkLHsSigType happy_var_1]-	)}--happyReduce_415 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_415 = happyMonadReduce 3# 156# happyReduction_415-happyReduction_415 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut157 happy_x_1 of { (HappyWrap157 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut172 happy_x_3 of { (HappyWrap172 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)-                                           >> return (mkLHsSigType happy_var_1 : happy_var_3))}}})-	) (\r -> happyReturn (happyIn172 r))--happyReduce_416 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_416 = happySpecReduce_1  157# happyReduction_416-happyReduction_416 happy_x_1-	 =  case happyOut174 happy_x_1 of { (HappyWrap174 happy_var_1) -> -	happyIn173-		 (happy_var_1-	)}--happyReduce_417 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_417 = happySpecReduce_0  157# happyReduction_417-happyReduction_417  =  happyIn173-		 ([]-	)--happyReduce_418 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_418 = happySpecReduce_1  158# happyReduction_418-happyReduction_418 happy_x_1-	 =  case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> -	happyIn174-		 ([happy_var_1]-	)}--happyReduce_419 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_419 = happyMonadReduce 3# 158# happyReduction_419-happyReduction_419 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut174 happy_x_3 of { (HappyWrap174 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)-                                          >> return (happy_var_1 : happy_var_3))}}})-	) (\r -> happyReturn (happyIn174 r))--happyReduce_420 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_420 = happyMonadReduce 3# 159# happyReduction_420-happyReduction_420 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut156 happy_x_3 of { (HappyWrap156 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)-                                          >> return [happy_var_1,happy_var_3])}}})-	) (\r -> happyReturn (happyIn175 r))--happyReduce_421 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_421 = happyMonadReduce 3# 159# happyReduction_421-happyReduction_421 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut175 happy_x_3 of { (HappyWrap175 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnVbar (gl happy_var_2)-                                          >> return (happy_var_1 : happy_var_3))}}})-	) (\r -> happyReturn (happyIn175 r))--happyReduce_422 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_422 = happySpecReduce_2  160# happyReduction_422-happyReduction_422 happy_x_2-	happy_x_1-	 =  case happyOut177 happy_x_1 of { (HappyWrap177 happy_var_1) -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	happyIn176-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_423 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_423 = happySpecReduce_0  160# happyReduction_423-happyReduction_423  =  happyIn176-		 ([]-	)--happyReduce_424 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_424 = happySpecReduce_1  161# happyReduction_424-happyReduction_424 happy_x_1-	 =  case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> -	happyIn177-		 (sL1 happy_var_1 (UserTyVar noExtField happy_var_1)-	)}--happyReduce_425 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_425 = happyMonadReduce 5# 161# happyReduction_425-happyReduction_425 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut182 happy_x_4 of { (HappyWrap182 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	( ams (sLL happy_var_1 happy_var_5  (KindedTyVar noExtField happy_var_2 happy_var_4))-                                               [mop happy_var_1,mu AnnDcolon happy_var_3-                                               ,mcp happy_var_5])}}}}})-	) (\r -> happyReturn (happyIn177 r))--happyReduce_426 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_426 = happySpecReduce_0  162# happyReduction_426-happyReduction_426  =  happyIn178-		 (noLoc ([],[])-	)--happyReduce_427 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_427 = happySpecReduce_2  162# happyReduction_427-happyReduction_427 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut179 happy_x_2 of { (HappyWrap179 happy_var_2) -> -	happyIn178-		 ((sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]-                                                 ,reverse (unLoc happy_var_2)))-	)}}--happyReduce_428 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_428 = happyMonadReduce 3# 163# happyReduction_428-happyReduction_428 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut179 happy_x_1 of { (HappyWrap179 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut180 happy_x_3 of { (HappyWrap180 happy_var_3) -> -	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2)-                           >> return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})-	) (\r -> happyReturn (happyIn179 r))--happyReduce_429 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_429 = happySpecReduce_1  163# happyReduction_429-happyReduction_429 happy_x_1-	 =  case happyOut180 happy_x_1 of { (HappyWrap180 happy_var_1) -> -	happyIn179-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_430 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_430 = happyMonadReduce 3# 164# happyReduction_430-happyReduction_430 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut181 happy_x_1 of { (HappyWrap181 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut181 happy_x_3 of { (HappyWrap181 happy_var_3) -> -	( ams (L (comb3 happy_var_1 happy_var_2 happy_var_3)-                                       (reverse (unLoc happy_var_1), reverse (unLoc happy_var_3)))-                                       [mu AnnRarrow happy_var_2])}}})-	) (\r -> happyReturn (happyIn180 r))--happyReduce_431 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_431 = happySpecReduce_0  165# happyReduction_431-happyReduction_431  =  happyIn181-		 (noLoc []-	)--happyReduce_432 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_432 = happySpecReduce_2  165# happyReduction_432-happyReduction_432 happy_x_2-	happy_x_1-	 =  case happyOut181 happy_x_1 of { (HappyWrap181 happy_var_1) -> -	case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> -	happyIn181-		 (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)-	)}}--happyReduce_433 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_433 = happySpecReduce_1  166# happyReduction_433-happyReduction_433 happy_x_1-	 =  case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> -	happyIn182-		 (happy_var_1-	)}--happyReduce_434 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_434 = happyMonadReduce 4# 167# happyReduction_434-happyReduction_434 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut184 happy_x_3 of { (HappyWrap184 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( checkEmptyGADTs $-                                                      L (comb2 happy_var_1 happy_var_3)-                                                        ([mj AnnWhere happy_var_1-                                                         ,moc happy_var_2-                                                         ,mcc happy_var_4]-                                                        , unLoc happy_var_3))}}}})-	) (\r -> happyReturn (happyIn183 r))--happyReduce_435 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_435 = happyMonadReduce 4# 167# happyReduction_435-happyReduction_435 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut184 happy_x_3 of { (HappyWrap184 happy_var_3) -> -	( checkEmptyGADTs $-                                                      L (comb2 happy_var_1 happy_var_3)-                                                        ([mj AnnWhere happy_var_1]-                                                        , unLoc happy_var_3))}})-	) (\r -> happyReturn (happyIn183 r))--happyReduce_436 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_436 = happySpecReduce_0  167# happyReduction_436-happyReduction_436  =  happyIn183-		 (noLoc ([],[])-	)--happyReduce_437 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_437 = happyMonadReduce 3# 168# happyReduction_437-happyReduction_437 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut185 happy_x_1 of { (HappyWrap185 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut184 happy_x_3 of { (HappyWrap184 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnSemi (gl happy_var_2)-                     >> return (L (comb2 happy_var_1 happy_var_3) (happy_var_1 : unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn184 r))--happyReduce_438 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_438 = happySpecReduce_1  168# happyReduction_438-happyReduction_438 happy_x_1-	 =  case happyOut185 happy_x_1 of { (HappyWrap185 happy_var_1) -> -	happyIn184-		 (L (gl happy_var_1) [happy_var_1]-	)}--happyReduce_439 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_439 = happySpecReduce_0  168# happyReduction_439-happyReduction_439  =  happyIn184-		 (noLoc []-	)--happyReduce_440 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_440 = happyMonadReduce 3# 169# happyReduction_440-happyReduction_440 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> -	case happyOut186 happy_x_3 of { (HappyWrap186 happy_var_3) -> -	( return $ addConDoc happy_var_3 happy_var_1)}})-	) (\r -> happyReturn (happyIn185 r))--happyReduce_441 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_441 = happyMonadReduce 1# 169# happyReduction_441-happyReduction_441 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut186 happy_x_1 of { (HappyWrap186 happy_var_1) -> -	( return happy_var_1)})-	) (\r -> happyReturn (happyIn185 r))--happyReduce_442 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_442 = happyMonadReduce 3# 170# happyReduction_442-happyReduction_442 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut276 happy_x_1 of { (HappyWrap276 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> -	( let (gadt,anns) = mkGadtDecl (unLoc happy_var_1) happy_var_3-                   in ams (sLL happy_var_1 happy_var_3 gadt)-                       (mu AnnDcolon happy_var_2:anns))}}})-	) (\r -> happyReturn (happyIn186 r))--happyReduce_443 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_443 = happySpecReduce_3  171# happyReduction_443-happyReduction_443 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut188 happy_x_3 of { (HappyWrap188 happy_var_3) -> -	happyIn187-		 (L (comb2 happy_var_2 happy_var_3) ([mj AnnEqual happy_var_2]-                                                     ,addConDocs (unLoc happy_var_3) happy_var_1)-	)}}}--happyReduce_444 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_444 = happyMonadReduce 5# 172# happyReduction_444-happyReduction_444 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut188 happy_x_1 of { (HappyWrap188 happy_var_1) -> -	case happyOut328 happy_x_2 of { (HappyWrap328 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut327 happy_x_4 of { (HappyWrap327 happy_var_4) -> -	case happyOut189 happy_x_5 of { (HappyWrap189 happy_var_5) -> -	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_3)-               >> return (sLL happy_var_1 happy_var_5 (addConDoc happy_var_5 happy_var_2 : addConDocFirst (unLoc happy_var_1) happy_var_4)))}}}}})-	) (\r -> happyReturn (happyIn188 r))--happyReduce_445 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_445 = happySpecReduce_1  172# happyReduction_445-happyReduction_445 happy_x_1-	 =  case happyOut189 happy_x_1 of { (HappyWrap189 happy_var_1) -> -	happyIn188-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_446 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_446 = happyMonadReduce 5# 173# happyReduction_446-happyReduction_446 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> -	case happyOut190 happy_x_2 of { (HappyWrap190 happy_var_2) -> -	case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut191 happy_x_5 of { (HappyWrap191 happy_var_5) -> -	( ams (let (con,details,doc_prev) = unLoc happy_var_5 in-                  addConDoc (L (comb4 happy_var_2 happy_var_3 happy_var_4 happy_var_5) (mkConDeclH98 con-                                                       (snd $ unLoc happy_var_2)-                                                       (Just happy_var_3)-                                                       details))-                            (happy_var_1 `mplus` doc_prev))-                        (mu AnnDarrow happy_var_4:(fst $ unLoc happy_var_2)))}}}}})-	) (\r -> happyReturn (happyIn189 r))--happyReduce_447 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_447 = happyMonadReduce 3# 173# happyReduction_447-happyReduction_447 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> -	case happyOut190 happy_x_2 of { (HappyWrap190 happy_var_2) -> -	case happyOut191 happy_x_3 of { (HappyWrap191 happy_var_3) -> -	( ams ( let (con,details,doc_prev) = unLoc happy_var_3 in-                  addConDoc (L (comb2 happy_var_2 happy_var_3) (mkConDeclH98 con-                                                      (snd $ unLoc happy_var_2)-                                                      Nothing   -- No context-                                                      details))-                            (happy_var_1 `mplus` doc_prev))-                       (fst $ unLoc happy_var_2))}}})-	) (\r -> happyReturn (happyIn189 r))--happyReduce_448 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_448 = happySpecReduce_3  174# happyReduction_448-happyReduction_448 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn190-		 (sLL happy_var_1 happy_var_3 ([mu AnnForall happy_var_1,mj AnnDot happy_var_3], Just happy_var_2)-	)}}}--happyReduce_449 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_449 = happySpecReduce_0  174# happyReduction_449-happyReduction_449  =  happyIn190-		 (noLoc ([], Nothing)-	)--happyReduce_450 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_450 = happyMonadReduce 1# 175# happyReduction_450-happyReduction_450 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> -	( do { c <- mergeDataCon (unLoc happy_var_1)-                                                 ; return $ sL1 happy_var_1 c })})-	) (\r -> happyReturn (happyIn191 r))--happyReduce_451 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_451 = happySpecReduce_0  176# happyReduction_451-happyReduction_451  =  happyIn192-		 ([]-	)--happyReduce_452 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_452 = happySpecReduce_1  176# happyReduction_452-happyReduction_452 happy_x_1-	 =  case happyOut193 happy_x_1 of { (HappyWrap193 happy_var_1) -> -	happyIn192-		 (happy_var_1-	)}--happyReduce_453 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_453 = happyMonadReduce 5# 177# happyReduction_453-happyReduction_453 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut194 happy_x_1 of { (HappyWrap194 happy_var_1) -> -	case happyOut328 happy_x_2 of { (HappyWrap328 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut327 happy_x_4 of { (HappyWrap327 happy_var_4) -> -	case happyOut193 happy_x_5 of { (HappyWrap193 happy_var_5) -> -	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_3) >>-               return ((addFieldDoc happy_var_1 happy_var_4) : addFieldDocs happy_var_5 happy_var_2))}}}}})-	) (\r -> happyReturn (happyIn193 r))--happyReduce_454 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_454 = happySpecReduce_1  177# happyReduction_454-happyReduction_454 happy_x_1-	 =  case happyOut194 happy_x_1 of { (HappyWrap194 happy_var_1) -> -	happyIn193-		 ([happy_var_1]-	)}--happyReduce_455 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_455 = happyMonadReduce 5# 178# happyReduction_455-happyReduction_455 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut328 happy_x_1 of { (HappyWrap328 happy_var_1) -> -	case happyOut152 happy_x_2 of { (HappyWrap152 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> -	case happyOut327 happy_x_5 of { (HappyWrap327 happy_var_5) -> -	( ams (L (comb2 happy_var_2 happy_var_4)-                      (ConDeclField noExtField (reverse (map (\ln@(L l n) -> L l $ FieldOcc noExtField ln) (unLoc happy_var_2))) happy_var_4 (happy_var_1 `mplus` happy_var_5)))-                   [mu AnnDcolon happy_var_3])}}}}})-	) (\r -> happyReturn (happyIn194 r))--happyReduce_456 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_456 = happySpecReduce_0  179# happyReduction_456-happyReduction_456  =  happyIn195-		 (noLoc []-	)--happyReduce_457 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_457 = happySpecReduce_1  179# happyReduction_457-happyReduction_457 happy_x_1-	 =  case happyOut196 happy_x_1 of { (HappyWrap196 happy_var_1) -> -	happyIn195-		 (happy_var_1-	)}--happyReduce_458 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_458 = happySpecReduce_2  180# happyReduction_458-happyReduction_458 happy_x_2-	happy_x_1-	 =  case happyOut196 happy_x_1 of { (HappyWrap196 happy_var_1) -> -	case happyOut197 happy_x_2 of { (HappyWrap197 happy_var_2) -> -	happyIn196-		 (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1-	)}}--happyReduce_459 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_459 = happySpecReduce_1  180# happyReduction_459-happyReduction_459 happy_x_1-	 =  case happyOut197 happy_x_1 of { (HappyWrap197 happy_var_1) -> -	happyIn196-		 (sLL happy_var_1 happy_var_1 [happy_var_1]-	)}--happyReduce_460 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_460 = happyMonadReduce 2# 181# happyReduction_460-happyReduction_460 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut198 happy_x_2 of { (HappyWrap198 happy_var_2) -> -	( let { full_loc = comb2 happy_var_1 happy_var_2 }-                 in ams (L full_loc $ HsDerivingClause noExtField Nothing happy_var_2)-                        [mj AnnDeriving happy_var_1])}})-	) (\r -> happyReturn (happyIn197 r))--happyReduce_461 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_461 = happyMonadReduce 3# 181# happyReduction_461-happyReduction_461 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut84 happy_x_2 of { (HappyWrap84 happy_var_2) -> -	case happyOut198 happy_x_3 of { (HappyWrap198 happy_var_3) -> -	( let { full_loc = comb2 happy_var_1 happy_var_3 }-                 in ams (L full_loc $ HsDerivingClause noExtField (Just happy_var_2) happy_var_3)-                        [mj AnnDeriving happy_var_1])}}})-	) (\r -> happyReturn (happyIn197 r))--happyReduce_462 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_462 = happyMonadReduce 3# 181# happyReduction_462-happyReduction_462 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut198 happy_x_2 of { (HappyWrap198 happy_var_2) -> -	case happyOut85 happy_x_3 of { (HappyWrap85 happy_var_3) -> -	( let { full_loc = comb2 happy_var_1 happy_var_3 }-                 in ams (L full_loc $ HsDerivingClause noExtField (Just happy_var_3) happy_var_2)-                        [mj AnnDeriving happy_var_1])}}})-	) (\r -> happyReturn (happyIn197 r))--happyReduce_463 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_463 = happySpecReduce_1  182# happyReduction_463-happyReduction_463 happy_x_1-	 =  case happyOut287 happy_x_1 of { (HappyWrap287 happy_var_1) -> -	happyIn198-		 (sL1 happy_var_1 [mkLHsSigType happy_var_1]-	)}--happyReduce_464 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_464 = happyMonadReduce 2# 182# happyReduction_464-happyReduction_464 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 [])-                                     [mop happy_var_1,mcp happy_var_2])}})-	) (\r -> happyReturn (happyIn198 r))--happyReduce_465 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_465 = happyMonadReduce 3# 182# happyReduction_465-happyReduction_465 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut172 happy_x_2 of { (HappyWrap172 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 happy_var_2)-                                     [mop happy_var_1,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn198 r))--happyReduce_466 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_466 = happySpecReduce_1  183# happyReduction_466-happyReduction_466 happy_x_1-	 =  case happyOut200 happy_x_1 of { (HappyWrap200 happy_var_1) -> -	happyIn199-		 (sL1 happy_var_1 (DocD noExtField (unLoc happy_var_1))-	)}--happyReduce_467 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_467 = happySpecReduce_1  184# happyReduction_467-happyReduction_467 happy_x_1-	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> -	happyIn200-		 (sL1 happy_var_1 (DocCommentNext (unLoc happy_var_1))-	)}--happyReduce_468 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_468 = happySpecReduce_1  184# happyReduction_468-happyReduction_468 happy_x_1-	 =  case happyOut323 happy_x_1 of { (HappyWrap323 happy_var_1) -> -	happyIn200-		 (sL1 happy_var_1 (DocCommentPrev (unLoc happy_var_1))-	)}--happyReduce_469 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_469 = happySpecReduce_1  184# happyReduction_469-happyReduction_469 happy_x_1-	 =  case happyOut324 happy_x_1 of { (HappyWrap324 happy_var_1) -> -	happyIn200-		 (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocCommentNamed n doc)-	)}--happyReduce_470 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_470 = happySpecReduce_1  184# happyReduction_470-happyReduction_470 happy_x_1-	 =  case happyOut325 happy_x_1 of { (HappyWrap325 happy_var_1) -> -	happyIn200-		 (sL1 happy_var_1 (case (unLoc happy_var_1) of (n, doc) -> DocGroup n doc)-	)}--happyReduce_471 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_471 = happySpecReduce_1  185# happyReduction_471-happyReduction_471 happy_x_1-	 =  case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> -	happyIn201-		 (happy_var_1-	)}--happyReduce_472 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_472 = happyMonadReduce 3# 185# happyReduction_472-happyReduction_472 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOut148 happy_x_2 of { (HappyWrap148 happy_var_2) -> -	case happyOut203 happy_x_3 of { (HappyWrap203 happy_var_3) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                       do { (ann,r) <- checkValDef happy_var_1 (snd happy_var_2) happy_var_3;-                                        let { l = comb2 happy_var_1 happy_var_3 };-                                        -- Depending upon what the pattern looks like we might get either-                                        -- a FunBind or PatBind back from checkValDef. See Note-                                        -- [FunBind vs PatBind]-                                        case r of {-                                          (FunBind _ n _ _) ->-                                                amsL l (mj AnnFunId n:(fst happy_var_2)) >> return () ;-                                          (PatBind _ (L lh _lhs) _rhs _) ->-                                                amsL lh (fst happy_var_2) >> return () } ;-                                        _ <- amsL l (ann ++ (fst $ unLoc happy_var_3));-                                        return $! (sL l $ ValD noExtField r) })}}})-	) (\r -> happyReturn (happyIn201 r))--happyReduce_473 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_473 = happySpecReduce_1  185# happyReduction_473-happyReduction_473 happy_x_1-	 =  case happyOut111 happy_x_1 of { (HappyWrap111 happy_var_1) -> -	happyIn201-		 (happy_var_1-	)}--happyReduce_474 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_474 = happySpecReduce_1  185# happyReduction_474-happyReduction_474 happy_x_1-	 =  case happyOut199 happy_x_1 of { (HappyWrap199 happy_var_1) -> -	happyIn201-		 (happy_var_1-	)}--happyReduce_475 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_475 = happySpecReduce_1  186# happyReduction_475-happyReduction_475 happy_x_1-	 =  case happyOut201 happy_x_1 of { (HappyWrap201 happy_var_1) -> -	happyIn202-		 (happy_var_1-	)}--happyReduce_476 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_476 = happySpecReduce_1  186# happyReduction_476-happyReduction_476 happy_x_1-	 =  case happyOut220 happy_x_1 of { (HappyWrap220 happy_var_1) -> -	happyIn202-		 (sLL happy_var_1 happy_var_1 $ mkSpliceDecl happy_var_1-	)}--happyReduce_477 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_477 = happyMonadReduce 3# 187# happyReduction_477-happyReduction_477 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	case happyOut128 happy_x_3 of { (HappyWrap128 happy_var_3) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 -> return $-                                  sL (comb3 happy_var_1 happy_var_2 happy_var_3)-                                    ((mj AnnEqual happy_var_1 : (fst $ unLoc happy_var_3))-                                    ,GRHSs noExtField (unguardedRHS (comb3 happy_var_1 happy_var_2 happy_var_3) happy_var_2)-                                   (snd $ unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn203 r))--happyReduce_478 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_478 = happySpecReduce_2  187# happyReduction_478-happyReduction_478 happy_x_2-	happy_x_1-	 =  case happyOut204 happy_x_1 of { (HappyWrap204 happy_var_1) -> -	case happyOut128 happy_x_2 of { (HappyWrap128 happy_var_2) -> -	happyIn203-		 (sLL happy_var_1 happy_var_2  (fst $ unLoc happy_var_2-                                    ,GRHSs noExtField (reverse (unLoc happy_var_1))-                                                    (snd $ unLoc happy_var_2))-	)}}--happyReduce_479 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_479 = happySpecReduce_2  188# happyReduction_479-happyReduction_479 happy_x_2-	happy_x_1-	 =  case happyOut204 happy_x_1 of { (HappyWrap204 happy_var_1) -> -	case happyOut205 happy_x_2 of { (HappyWrap205 happy_var_2) -> -	happyIn204-		 (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)-	)}}--happyReduce_480 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_480 = happySpecReduce_1  188# happyReduction_480-happyReduction_480 happy_x_1-	 =  case happyOut205 happy_x_1 of { (HappyWrap205 happy_var_1) -> -	happyIn204-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_481 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_481 = happyMonadReduce 4# 189# happyReduction_481-happyReduction_481 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	( runECP_P happy_var_4 >>= \ happy_var_4 ->-                                     ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS noExtField (unLoc happy_var_2) happy_var_4)-                                         [mj AnnVbar happy_var_1,mj AnnEqual happy_var_3])}}}})-	) (\r -> happyReturn (happyIn205 r))--happyReduce_482 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_482 = happyMonadReduce 3# 190# happyReduction_482-happyReduction_482 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> -	( do { happy_var_1 <- runECP_P happy_var_1-                              ; v <- checkValSigLhs happy_var_1-                              ; _ <- amsL (comb2 happy_var_1 happy_var_3) [mu AnnDcolon happy_var_2]-                              ; return (sLL happy_var_1 happy_var_3 $ SigD noExtField $-                                  TypeSig noExtField [v] (mkLHsSigWcType happy_var_3))})}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_483 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_483 = happyMonadReduce 5# 190# happyReduction_483-happyReduction_483 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut152 happy_x_3 of { (HappyWrap152 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut151 happy_x_5 of { (HappyWrap151 happy_var_5) -> -	( do { let sig = TypeSig noExtField (happy_var_1 : reverse (unLoc happy_var_3))-                                     (mkLHsSigWcType happy_var_5)-                 ; addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2)-                 ; ams ( sLL happy_var_1 happy_var_5 $ SigD noExtField sig )-                       [mu AnnDcolon happy_var_4] })}}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_484 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_484 = happyMonadReduce 3# 190# happyReduction_484-happyReduction_484 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut73 happy_x_1 of { (HappyWrap73 happy_var_1) -> -	case happyOut72 happy_x_2 of { (HappyWrap72 happy_var_2) -> -	case happyOut74 happy_x_3 of { (HappyWrap74 happy_var_3) -> -	( checkPrecP happy_var_2 happy_var_3 >>-                 ams (sLL happy_var_1 happy_var_3 $ SigD noExtField-                        (FixSig noExtField (FixitySig noExtField (fromOL $ unLoc happy_var_3)-                                (Fixity (fst $ unLoc happy_var_2) (snd $ unLoc happy_var_2) (unLoc happy_var_1)))))-                     [mj AnnInfix happy_var_1,mj AnnVal happy_var_2])}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_485 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_485 = happySpecReduce_1  190# happyReduction_485-happyReduction_485 happy_x_1-	 =  case happyOut116 happy_x_1 of { (HappyWrap116 happy_var_1) -> -	happyIn206-		 (sLL happy_var_1 happy_var_1 . SigD noExtField . unLoc $ happy_var_1-	)}--happyReduce_486 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_486 = happyMonadReduce 4# 190# happyReduction_486-happyReduction_486 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut276 happy_x_2 of { (HappyWrap276 happy_var_2) -> -	case happyOut149 happy_x_3 of { (HappyWrap149 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( let (dcolon, tc) = happy_var_3-                   in ams-                       (sLL happy_var_1 happy_var_4-                         (SigD noExtField (CompleteMatchSig noExtField (getCOMPLETE_PRAGs happy_var_1) happy_var_2 tc)))-                    ([ mo happy_var_1 ] ++ dcolon ++ [mc happy_var_4]))}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_487 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_487 = happyMonadReduce 4# 190# happyReduction_487-happyReduction_487 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> -	case happyOut302 happy_x_3 of { (HappyWrap302 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( ams ((sLL happy_var_1 happy_var_4 $ SigD noExtField (InlineSig noExtField happy_var_3-                            (mkInlinePragma (getINLINE_PRAGs happy_var_1) (getINLINE happy_var_1)-                                            (snd happy_var_2)))))-                       ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_4]))}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_488 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_488 = happyMonadReduce 3# 190# happyReduction_488-happyReduction_488 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (SigD noExtField (SCCFunSig noExtField (getSCC_PRAGs happy_var_1) happy_var_2 Nothing)))-                 [mo happy_var_1, mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_489 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_489 = happyMonadReduce 4# 190# happyReduction_489-happyReduction_489 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( do { scc <- getSCC happy_var_3-                ; let str_lit = StringLiteral (getSTRINGs happy_var_3) scc-                ; ams (sLL happy_var_1 happy_var_4 (SigD noExtField (SCCFunSig noExtField (getSCC_PRAGs happy_var_1) happy_var_2 (Just ( sL1 happy_var_3 str_lit)))))-                      [mo happy_var_1, mc happy_var_4] })}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_490 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_490 = happyMonadReduce 6# 190# happyReduction_490-happyReduction_490 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> -	case happyOut302 happy_x_3 of { (HappyWrap302 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut153 happy_x_5 of { (HappyWrap153 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	( ams (-                 let inl_prag = mkInlinePragma (getSPEC_PRAGs happy_var_1)-                                             (NoUserInline, FunLike) (snd happy_var_2)-                  in sLL happy_var_1 happy_var_6 $ SigD noExtField (SpecSig noExtField happy_var_3 (fromOL happy_var_5) inl_prag))-                    (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_491 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_491 = happyMonadReduce 6# 190# happyReduction_491-happyReduction_491 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> -	case happyOut302 happy_x_3 of { (HappyWrap302 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut153 happy_x_5 of { (HappyWrap153 happy_var_5) -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	( ams (sLL happy_var_1 happy_var_6 $ SigD noExtField (SpecSig noExtField happy_var_3 (fromOL happy_var_5)-                               (mkInlinePragma (getSPEC_INLINE_PRAGs happy_var_1)-                                               (getSPEC_INLINE happy_var_1) (snd happy_var_2))))-                       (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)))}}}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_492 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_492 = happyMonadReduce 4# 190# happyReduction_492-happyReduction_492 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut171 happy_x_3 of { (HappyWrap171 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( ams (sLL happy_var_1 happy_var_4-                                  $ SigD noExtField (SpecInstSig noExtField (getSPEC_PRAGs happy_var_1) happy_var_3))-                       [mo happy_var_1,mj AnnInstance happy_var_2,mc happy_var_4])}}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_493 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_493 = happyMonadReduce 3# 190# happyReduction_493-happyReduction_493 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut265 happy_x_2 of { (HappyWrap265 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ SigD noExtField (MinimalSig noExtField (getMINIMAL_PRAGs happy_var_1) happy_var_2))-                   [mo happy_var_1,mc happy_var_3])}}})-	) (\r -> happyReturn (happyIn206 r))--happyReduce_494 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_494 = happySpecReduce_0  191# happyReduction_494-happyReduction_494  =  happyIn207-		 (([],Nothing)-	)--happyReduce_495 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_495 = happySpecReduce_1  191# happyReduction_495-happyReduction_495 happy_x_1-	 =  case happyOut208 happy_x_1 of { (HappyWrap208 happy_var_1) -> -	happyIn207-		 ((fst happy_var_1,Just (snd happy_var_1))-	)}--happyReduce_496 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_496 = happySpecReduce_3  192# happyReduction_496-happyReduction_496 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn208-		 (([mj AnnOpenS happy_var_1,mj AnnVal happy_var_2,mj AnnCloseS happy_var_3]-                                  ,ActiveAfter  (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))-	)}}}--happyReduce_497 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_497 = happyReduce 4# 192# happyReduction_497-happyReduction_497 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn208-		 ((happy_var_2++[mj AnnOpenS happy_var_1,mj AnnVal happy_var_3,mj AnnCloseS happy_var_4]-                                  ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))-	) `HappyStk` happyRest}}}}--happyReduce_498 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_498 = happySpecReduce_1  193# happyReduction_498-happyReduction_498 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn209-		 (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 (mkSrcSpanPs quoteSpan) quote)-	)}--happyReduce_499 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_499 = happySpecReduce_1  193# happyReduction_499-happyReduction_499 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn209-		 (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 (mkSrcSpanPs quoteSpan) quote)-	)}--happyReduce_500 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_500 = happySpecReduce_3  194# happyReduction_500-happyReduction_500 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut150 happy_x_3 of { (HappyWrap150 happy_var_3) -> -	happyIn210-		 (ECP $-                                   runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                   rejectPragmaPV happy_var_1 >>-                                   amms (mkHsTySigPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_3)-                                       [mu AnnDcolon happy_var_2]-	)}}}--happyReduce_501 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_501 = happyMonadReduce 3# 194# happyReduction_501-happyReduction_501 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                   runECP_P happy_var_3 >>= \ happy_var_3 ->-                                   fmap ecpFromCmd $-                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_1 happy_var_3-                                                        HsFirstOrderApp True)-                                       [mu Annlarrowtail happy_var_2])}}})-	) (\r -> happyReturn (happyIn210 r))--happyReduce_502 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_502 = happyMonadReduce 3# 194# happyReduction_502-happyReduction_502 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                   runECP_P happy_var_3 >>= \ happy_var_3 ->-                                   fmap ecpFromCmd $-                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_3 happy_var_1-                                                      HsFirstOrderApp False)-                                       [mu Annrarrowtail happy_var_2])}}})-	) (\r -> happyReturn (happyIn210 r))--happyReduce_503 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_503 = happyMonadReduce 3# 194# happyReduction_503-happyReduction_503 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                   runECP_P happy_var_3 >>= \ happy_var_3 ->-                                   fmap ecpFromCmd $-                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_1 happy_var_3-                                                      HsHigherOrderApp True)-                                       [mu AnnLarrowtail happy_var_2])}}})-	) (\r -> happyReturn (happyIn210 r))--happyReduce_504 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_504 = happyMonadReduce 3# 194# happyReduction_504-happyReduction_504 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                   runECP_P happy_var_3 >>= \ happy_var_3 ->-                                   fmap ecpFromCmd $-                                   ams (sLL happy_var_1 happy_var_3 $ HsCmdArrApp noExtField happy_var_3 happy_var_1-                                                      HsHigherOrderApp False)-                                       [mu AnnRarrowtail happy_var_2])}}})-	) (\r -> happyReturn (happyIn210 r))--happyReduce_505 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_505 = happySpecReduce_1  194# happyReduction_505-happyReduction_505 happy_x_1-	 =  case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	happyIn210-		 (happy_var_1-	)}--happyReduce_506 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_506 = happySpecReduce_1  194# happyReduction_506-happyReduction_506 happy_x_1-	 =  case happyOut329 happy_x_1 of { (HappyWrap329 happy_var_1) -> -	happyIn210-		 (happy_var_1-	)}--happyReduce_507 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_507 = happySpecReduce_1  195# happyReduction_507-happyReduction_507 happy_x_1-	 =  case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> -	happyIn211-		 (happy_var_1-	)}--happyReduce_508 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_508 = happySpecReduce_3  195# happyReduction_508-happyReduction_508 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOut293 happy_x_2 of { (HappyWrap293 happy_var_2) -> -	case happyOut212 happy_x_3 of { (HappyWrap212 happy_var_3) -> -	happyIn211-		 (ECP $-                                 superInfixOp $-                                 happy_var_2 >>= \ happy_var_2 ->-                                 runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                 runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                 rejectPragmaPV happy_var_1 >>-                                 amms (mkHsOpAppPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_2 happy_var_3)-                                     [mj AnnVal happy_var_2]-	)}}}--happyReduce_509 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_509 = happySpecReduce_1  196# happyReduction_509-happyReduction_509 happy_x_1-	 =  case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> -	happyIn212-		 (happy_var_1-	)}--happyReduce_510 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_510 = happySpecReduce_1  196# happyReduction_510-happyReduction_510 happy_x_1-	 =  case happyOut330 happy_x_1 of { (HappyWrap330 happy_var_1) -> -	happyIn212-		 (happy_var_1-	)}--happyReduce_511 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_511 = happySpecReduce_2  197# happyReduction_511-happyReduction_511 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut216 happy_x_2 of { (HappyWrap216 happy_var_2) -> -	happyIn213-		 (ECP $-                                           runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                           amms (mkHsNegAppPV (comb2 happy_var_1 happy_var_2) happy_var_2)-                                               [mj AnnMinus happy_var_1]-	)}}--happyReduce_512 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_512 = happySpecReduce_1  197# happyReduction_512-happyReduction_512 happy_x_1-	 =  case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> -	happyIn213-		 (happy_var_1-	)}--happyReduce_513 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_513 = happySpecReduce_1  198# happyReduction_513-happyReduction_513 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn214-		 (([happy_var_1],True)-	)}--happyReduce_514 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_514 = happySpecReduce_0  198# happyReduction_514-happyReduction_514  =  happyIn214-		 (([],False)-	)--happyReduce_515 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_515 = happyMonadReduce 3# 199# happyReduction_515-happyReduction_515 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( do scc <- getSCC happy_var_2-                                          ; return $ sLL happy_var_1 happy_var_3-                                             ([mo happy_var_1,mj AnnValStr happy_var_2,mc happy_var_3],-                                              HsPragSCC noExtField-                                                (getSCC_PRAGs happy_var_1)-                                                (StringLiteral (getSTRINGs happy_var_2) scc)))}}})-	) (\r -> happyReturn (happyIn215 r))--happyReduce_516 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_516 = happySpecReduce_3  199# happyReduction_516-happyReduction_516 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn215-		 (sLL happy_var_1 happy_var_3 ([mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3],-                                                  HsPragSCC noExtField-                                                    (getSCC_PRAGs happy_var_1)-                                                    (StringLiteral NoSourceText (getVARID happy_var_2)))-	)}}}--happyReduce_517 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_517 = happyReduce 10# 199# happyReduction_517-happyReduction_517 (happy_x_10 `HappyStk`-	happy_x_9 `HappyStk`-	happy_x_8 `HappyStk`-	happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	case happyOutTok happy_x_6 of { happy_var_6 -> -	case happyOutTok happy_x_7 of { happy_var_7 -> -	case happyOutTok happy_x_8 of { happy_var_8 -> -	case happyOutTok happy_x_9 of { happy_var_9 -> -	case happyOutTok happy_x_10 of { happy_var_10 -> -	happyIn215-		 (let getINT = fromInteger . il_value . getINTEGER in-                                        sLL happy_var_1 happy_var_10 $ ([mo happy_var_1,mj AnnVal happy_var_2-                                              ,mj AnnVal happy_var_3,mj AnnColon happy_var_4-                                              ,mj AnnVal happy_var_5,mj AnnMinus happy_var_6-                                              ,mj AnnVal happy_var_7,mj AnnColon happy_var_8-                                              ,mj AnnVal happy_var_9,mc happy_var_10],-                                              HsPragTick noExtField-                                                (getGENERATED_PRAGs happy_var_1)-                                                (getStringLiteral happy_var_2,-                                                 (getINT happy_var_3, getINT happy_var_5),-                                                 (getINT happy_var_7, getINT happy_var_9))-                                                ((getINTEGERs happy_var_3, getINTEGERs happy_var_5),-                                                 (getINTEGERs happy_var_7, getINTEGERs happy_var_9) ))-	) `HappyStk` happyRest}}}}}}}}}}--happyReduce_518 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_518 = happySpecReduce_3  199# happyReduction_518-happyReduction_518 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn215-		 (sLL happy_var_1 happy_var_3 $-            ([mo happy_var_1,mj AnnVal happy_var_2,mc happy_var_3],-             HsPragCore noExtField (getCORE_PRAGs happy_var_1) (getStringLiteral happy_var_2))-	)}}}--happyReduce_519 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_519 = happySpecReduce_2  200# happyReduction_519-happyReduction_519 happy_x_2-	happy_x_1-	 =  case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> -	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> -	happyIn216-		 (ECP $-                                          superFunArg $-                                          runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                          runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                          mkHsAppPV (comb2 happy_var_1 happy_var_2) happy_var_1 happy_var_2-	)}}--happyReduce_520 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_520 = happyMonadReduce 3# 200# happyReduction_520-happyReduction_520 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut170 happy_x_3 of { (HappyWrap170 happy_var_3) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                        runPV (checkExpBlockArguments happy_var_1) >>= \_ ->-                                        fmap ecpFromExp $-                                        ams (sLL happy_var_1 happy_var_3 $ HsAppType noExtField happy_var_1 (mkHsWildCardBndrs happy_var_3))-                                            [mj AnnAt happy_var_2])}}})-	) (\r -> happyReturn (happyIn216 r))--happyReduce_521 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_521 = happyMonadReduce 2# 200# happyReduction_521-happyReduction_521 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                        fmap ecpFromExp $-                                        ams (sLL happy_var_1 happy_var_2 $ HsStatic noExtField happy_var_2)-                                            [mj AnnStatic happy_var_1])}})-	) (\r -> happyReturn (happyIn216 r))--happyReduce_522 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_522 = happySpecReduce_1  200# happyReduction_522-happyReduction_522 happy_x_1-	 =  case happyOut217 happy_x_1 of { (HappyWrap217 happy_var_1) -> -	happyIn216-		 (happy_var_1-	)}--happyReduce_523 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_523 = happySpecReduce_3  201# happyReduction_523-happyReduction_523 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut217 happy_x_3 of { (HappyWrap217 happy_var_3) -> -	happyIn217-		 (ECP $-                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                   amms (mkHsAsPatPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_3) [mj AnnAt happy_var_2]-	)}}}--happyReduce_524 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_524 = happySpecReduce_2  201# happyReduction_524-happyReduction_524 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> -	happyIn217-		 (ECP $-                                   runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                   amms (mkHsLazyPatPV (comb2 happy_var_1 happy_var_2) happy_var_2) [mj AnnTilde happy_var_1]-	)}}--happyReduce_525 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_525 = happySpecReduce_2  201# happyReduction_525-happyReduction_525 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> -	happyIn217-		 (ECP $-                                   runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                   amms (mkHsBangPatPV (comb2 happy_var_1 happy_var_2) happy_var_2) [mj AnnBang happy_var_1]-	)}}--happyReduce_526 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_526 = happyReduce 5# 201# happyReduction_526-happyReduction_526 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut250 happy_x_2 of { (HappyWrap250 happy_var_2) -> -	case happyOut251 happy_x_3 of { (HappyWrap251 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut210 happy_x_5 of { (HappyWrap210 happy_var_5) -> -	happyIn217-		 (ECP $-                      runECP_PV happy_var_5 >>= \ happy_var_5 ->-                      amms (mkHsLamPV (comb2 happy_var_1 happy_var_5) (mkMatchGroup FromSource-                            [sLL happy_var_1 happy_var_5 $ Match { m_ext = noExtField-                                               , m_ctxt = LambdaExpr-                                               , m_pats = happy_var_2:happy_var_3-                                               , m_grhss = unguardedGRHSs happy_var_5 }]))-                          [mj AnnLam happy_var_1, mu AnnRarrow happy_var_4]-	) `HappyStk` happyRest}}}}}--happyReduce_527 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_527 = happyReduce 4# 201# happyReduction_527-happyReduction_527 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	happyIn217-		 (ECP $-                                           runECP_PV happy_var_4 >>= \ happy_var_4 ->-                                           amms (mkHsLetPV (comb2 happy_var_1 happy_var_4) (snd (unLoc happy_var_2)) happy_var_4)-                                               (mj AnnLet happy_var_1:mj AnnIn happy_var_3-                                                 :(fst $ unLoc happy_var_2))-	) `HappyStk` happyRest}}}}--happyReduce_528 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_528 = happyMonadReduce 3# 201# happyReduction_528-happyReduction_528 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut239 happy_x_3 of { (HappyWrap239 happy_var_3) -> -	( runPV happy_var_3 >>= \ happy_var_3 ->-               fmap ecpFromExp $-               ams (sLL happy_var_1 happy_var_3 $ HsLamCase noExtField-                                   (mkMatchGroup FromSource (snd $ unLoc happy_var_3)))-                   (mj AnnLam happy_var_1:mj AnnCase happy_var_2:(fst $ unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn217 r))--happyReduce_529 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_529 = happyMonadReduce 8# 201# happyReduction_529-happyReduction_529 (happy_x_8 `HappyStk`-	happy_x_7 `HappyStk`-	happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	case happyOut214 happy_x_3 of { (HappyWrap214 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut210 happy_x_5 of { (HappyWrap210 happy_var_5) -> -	case happyOut214 happy_x_6 of { (HappyWrap214 happy_var_6) -> -	case happyOutTok happy_x_7 of { happy_var_7 -> -	case happyOut210 happy_x_8 of { (HappyWrap210 happy_var_8) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                            return $ ECP $-                              runECP_PV happy_var_5 >>= \ happy_var_5 ->-                              runECP_PV happy_var_8 >>= \ happy_var_8 ->-                              amms (mkHsIfPV (comb2 happy_var_1 happy_var_8) happy_var_2 (snd happy_var_3) happy_var_5 (snd happy_var_6) happy_var_8)-                                  (mj AnnIf happy_var_1:mj AnnThen happy_var_4-                                     :mj AnnElse happy_var_7-                                     :(map (\l -> mj AnnSemi l) (fst happy_var_3))-                                    ++(map (\l -> mj AnnSemi l) (fst happy_var_6))))}}}}}}}})-	) (\r -> happyReturn (happyIn217 r))--happyReduce_530 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_530 = happyMonadReduce 2# 201# happyReduction_530-happyReduction_530 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut246 happy_x_2 of { (HappyWrap246 happy_var_2) -> -	( hintMultiWayIf (getLoc happy_var_1) >>= \_ ->-                                           fmap ecpFromExp $-                                           ams (sLL happy_var_1 happy_var_2 $ HsMultiIf noExtField-                                                     (reverse $ snd $ unLoc happy_var_2))-                                               (mj AnnIf happy_var_1:(fst $ unLoc happy_var_2)))}})-	) (\r -> happyReturn (happyIn217 r))--happyReduce_531 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_531 = happyMonadReduce 4# 201# happyReduction_531-happyReduction_531 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut239 happy_x_4 of { (HappyWrap239 happy_var_4) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                         return $ ECP $-                                           happy_var_4 >>= \ happy_var_4 ->-                                           amms (mkHsCasePV (comb3 happy_var_1 happy_var_3 happy_var_4) happy_var_2 (mkMatchGroup-                                                   FromSource (snd $ unLoc happy_var_4)))-                                               (mj AnnCase happy_var_1:mj AnnOf happy_var_3-                                                  :(fst $ unLoc happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn217 r))--happyReduce_532 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_532 = happySpecReduce_2  201# happyReduction_532-happyReduction_532 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut252 happy_x_2 of { (HappyWrap252 happy_var_2) -> -	happyIn217-		 (ECP $-                                        happy_var_2 >>= \ happy_var_2 ->-                                        amms (mkHsDoPV (comb2 happy_var_1 happy_var_2) (mapLoc snd happy_var_2))-                                               (mj AnnDo happy_var_1:(fst $ unLoc happy_var_2))-	)}}--happyReduce_533 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_533 = happyMonadReduce 2# 201# happyReduction_533-happyReduction_533 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut252 happy_x_2 of { (HappyWrap252 happy_var_2) -> -	( runPV happy_var_2 >>= \ happy_var_2 ->-                                       fmap ecpFromExp $-                                       ams (L (comb2 happy_var_1 happy_var_2)-                                              (mkHsDo MDoExpr (snd $ unLoc happy_var_2)))-                                           (mj AnnMdo happy_var_1:(fst $ unLoc happy_var_2)))}})-	) (\r -> happyReturn (happyIn217 r))--happyReduce_534 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_534 = happyMonadReduce 4# 201# happyReduction_534-happyReduction_534 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut217 happy_x_2 of { (HappyWrap217 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	( (checkPattern <=< runECP_P) happy_var_2 >>= \ p ->-                           runECP_P happy_var_4 >>= \ happy_var_4@cmd ->-                           fmap ecpFromExp $-                           ams (sLL happy_var_1 happy_var_4 $ HsProc noExtField p (sLL happy_var_1 happy_var_4 $ HsCmdTop noExtField cmd))-                                            -- TODO: is LL right here?-                               [mj AnnProc happy_var_1,mu AnnRarrow happy_var_3])}}}})-	) (\r -> happyReturn (happyIn217 r))--happyReduce_535 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_535 = happySpecReduce_1  201# happyReduction_535-happyReduction_535 happy_x_1-	 =  case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> -	happyIn217-		 (happy_var_1-	)}--happyReduce_536 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_536 = happyReduce 4# 202# happyReduction_536-happyReduction_536 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut258 happy_x_3 of { (HappyWrap258 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn218-		 (ECP $-                                  runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                  happy_var_3 >>= \ happy_var_3 ->-                                  amms (mkHsRecordPV (comb2 happy_var_1 happy_var_4) (comb2 happy_var_2 happy_var_4) happy_var_1 (snd happy_var_3))-                                       (moc happy_var_2:mcc happy_var_4:(fst happy_var_3))-	) `HappyStk` happyRest}}}}--happyReduce_537 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_537 = happySpecReduce_1  202# happyReduction_537-happyReduction_537 happy_x_1-	 =  case happyOut219 happy_x_1 of { (HappyWrap219 happy_var_1) -> -	happyIn218-		 (happy_var_1-	)}--happyReduce_538 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_538 = happySpecReduce_1  203# happyReduction_538-happyReduction_538 happy_x_1-	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> -	happyIn219-		 (ECP $ mkHsVarPV $! happy_var_1-	)}--happyReduce_539 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_539 = happySpecReduce_1  203# happyReduction_539-happyReduction_539 happy_x_1-	 =  case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> -	happyIn219-		 (ECP $ mkHsVarPV $! happy_var_1-	)}--happyReduce_540 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_540 = happySpecReduce_1  203# happyReduction_540-happyReduction_540 happy_x_1-	 =  case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> -	happyIn219-		 (ecpFromExp $ sL1 happy_var_1 (HsIPVar noExtField $! unLoc happy_var_1)-	)}--happyReduce_541 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_541 = happySpecReduce_1  203# happyReduction_541-happyReduction_541 happy_x_1-	 =  case happyOut264 happy_x_1 of { (HappyWrap264 happy_var_1) -> -	happyIn219-		 (ecpFromExp $ sL1 happy_var_1 (HsOverLabel noExtField Nothing $! unLoc happy_var_1)-	)}--happyReduce_542 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_542 = happySpecReduce_1  203# happyReduction_542-happyReduction_542 happy_x_1-	 =  case happyOut316 happy_x_1 of { (HappyWrap316 happy_var_1) -> -	happyIn219-		 (ECP $ mkHsLitPV $! happy_var_1-	)}--happyReduce_543 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_543 = happySpecReduce_1  203# happyReduction_543-happyReduction_543 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn219-		 (ECP $ mkHsOverLitPV (sL1 happy_var_1 $ mkHsIntegral   (getINTEGER  happy_var_1))-	)}--happyReduce_544 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_544 = happySpecReduce_1  203# happyReduction_544-happyReduction_544 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn219-		 (ECP $ mkHsOverLitPV (sL1 happy_var_1 $ mkHsFractional (getRATIONAL happy_var_1))-	)}--happyReduce_545 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_545 = happySpecReduce_3  203# happyReduction_545-happyReduction_545 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn219-		 (ECP $-                                           runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                           amms (mkHsParPV (comb2 happy_var_1 happy_var_3) happy_var_2) [mop happy_var_1,mcp happy_var_3]-	)}}}--happyReduce_546 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_546 = happySpecReduce_3  203# happyReduction_546-happyReduction_546 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut228 happy_x_2 of { (HappyWrap228 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn219-		 (ECP $-                                           happy_var_2 >>= \ happy_var_2 ->-                                           amms (mkSumOrTuplePV (comb2 happy_var_1 happy_var_3) Boxed (snd happy_var_2))-                                                ((mop happy_var_1:fst happy_var_2) ++ [mcp happy_var_3])-	)}}}--happyReduce_547 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_547 = happySpecReduce_3  203# happyReduction_547-happyReduction_547 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn219-		 (ECP $-                                           runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                           amms (mkSumOrTuplePV (comb2 happy_var_1 happy_var_3) Unboxed (Tuple [L (gl happy_var_2) (Just happy_var_2)]))-                                                [mo happy_var_1,mc happy_var_3]-	)}}}--happyReduce_548 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_548 = happySpecReduce_3  203# happyReduction_548-happyReduction_548 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut228 happy_x_2 of { (HappyWrap228 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn219-		 (ECP $-                                           happy_var_2 >>= \ happy_var_2 ->-                                           amms (mkSumOrTuplePV (comb2 happy_var_1 happy_var_3) Unboxed (snd happy_var_2))-                                                ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_3])-	)}}}--happyReduce_549 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_549 = happySpecReduce_3  203# happyReduction_549-happyReduction_549 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut231 happy_x_2 of { (HappyWrap231 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn219-		 (ECP $ happy_var_2 (comb2 happy_var_1 happy_var_3) >>= \a -> ams a [mos happy_var_1,mcs happy_var_3]-	)}}}--happyReduce_550 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_550 = happySpecReduce_1  203# happyReduction_550-happyReduction_550 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn219-		 (ECP $ mkHsWildCardPV (getLoc happy_var_1)-	)}--happyReduce_551 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_551 = happySpecReduce_1  203# happyReduction_551-happyReduction_551 happy_x_1-	 =  case happyOut221 happy_x_1 of { (HappyWrap221 happy_var_1) -> -	happyIn219-		 (ECP $ mkHsSplicePV happy_var_1-	)}--happyReduce_552 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_552 = happySpecReduce_1  203# happyReduction_552-happyReduction_552 happy_x_1-	 =  case happyOut222 happy_x_1 of { (HappyWrap222 happy_var_1) -> -	happyIn219-		 (ecpFromExp $ mapLoc (HsSpliceE noExtField) happy_var_1-	)}--happyReduce_553 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_553 = happyMonadReduce 2# 203# happyReduction_553-happyReduction_553 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> -	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField True  (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_554 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_554 = happyMonadReduce 2# 203# happyReduction_554-happyReduction_554 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut273 happy_x_2 of { (HappyWrap273 happy_var_2) -> -	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField True  (unLoc happy_var_2))) [mj AnnSimpleQuote happy_var_1,mj AnnName happy_var_2])}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_555 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_555 = happyMonadReduce 2# 203# happyReduction_555-happyReduction_555 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> -	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_556 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_556 = happyMonadReduce 2# 203# happyReduction_556-happyReduction_556 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut281 happy_x_2 of { (HappyWrap281 happy_var_2) -> -	( fmap ecpFromExp $ ams (sLL happy_var_1 happy_var_2 $ HsBracket noExtField (VarBr noExtField False (unLoc happy_var_2))) [mj AnnThTyQuote happy_var_1,mj AnnName happy_var_2])}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_557 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_557 = happyMonadReduce 1# 203# happyReduction_557-happyReduction_557 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( reportEmptyDoubleQuotes (getLoc happy_var_1))})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_558 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_558 = happyMonadReduce 3# 203# happyReduction_558-happyReduction_558 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                 fmap ecpFromExp $-                                 ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (ExpBr noExtField happy_var_2))-                                      (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1, mu AnnCloseQ happy_var_3]-                                                    else [mu AnnOpenEQ happy_var_1,mu AnnCloseQ happy_var_3]))}}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_559 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_559 = happyMonadReduce 3# 203# happyReduction_559-happyReduction_559 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                 fmap ecpFromExp $-                                 ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (TExpBr noExtField happy_var_2))-                                      (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1,mc happy_var_3] else [mo happy_var_1,mc happy_var_3]))}}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_560 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_560 = happyMonadReduce 3# 203# happyReduction_560-happyReduction_560 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut156 happy_x_2 of { (HappyWrap156 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( fmap ecpFromExp $-                                 ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (TypBr noExtField happy_var_2)) [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_561 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_561 = happyMonadReduce 3# 203# happyReduction_561-happyReduction_561 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut211 happy_x_2 of { (HappyWrap211 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( (checkPattern <=< runECP_P) happy_var_2 >>= \p ->-                                      fmap ecpFromExp $-                                      ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (PatBr noExtField p))-                                          [mo happy_var_1,mu AnnCloseQ happy_var_3])}}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_562 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_562 = happyMonadReduce 3# 203# happyReduction_562-happyReduction_562 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut225 happy_x_2 of { (HappyWrap225 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( fmap ecpFromExp $-                                  ams (sLL happy_var_1 happy_var_3 $ HsBracket noExtField (DecBrL noExtField (snd happy_var_2)))-                                      (mo happy_var_1:mu AnnCloseQ happy_var_3:fst happy_var_2))}}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_563 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_563 = happySpecReduce_1  203# happyReduction_563-happyReduction_563 happy_x_1-	 =  case happyOut209 happy_x_1 of { (HappyWrap209 happy_var_1) -> -	happyIn219-		 (ECP $ mkHsSplicePV happy_var_1-	)}--happyReduce_564 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_564 = happyMonadReduce 4# 203# happyReduction_564-happyReduction_564 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut219 happy_x_2 of { (HappyWrap219 happy_var_2) -> -	case happyOut223 happy_x_3 of { (HappyWrap223 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                      fmap ecpFromCmd $-                                      ams (sLL happy_var_1 happy_var_4 $ HsCmdArrForm noExtField happy_var_2 Prefix-                                                           Nothing (reverse happy_var_3))-                                          [mu AnnOpenB happy_var_1,mu AnnCloseB happy_var_4])}}}})-	) (\r -> happyReturn (happyIn219 r))--happyReduce_565 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_565 = happySpecReduce_1  204# happyReduction_565-happyReduction_565 happy_x_1-	 =  case happyOut221 happy_x_1 of { (HappyWrap221 happy_var_1) -> -	happyIn220-		 (mapLoc (HsSpliceE noExtField) happy_var_1-	)}--happyReduce_566 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_566 = happySpecReduce_1  204# happyReduction_566-happyReduction_566 happy_x_1-	 =  case happyOut222 happy_x_1 of { (HappyWrap222 happy_var_1) -> -	happyIn220-		 (mapLoc (HsSpliceE noExtField) happy_var_1-	)}--happyReduce_567 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_567 = happyMonadReduce 2# 205# happyReduction_567-happyReduction_567 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut219 happy_x_2 of { (HappyWrap219 happy_var_2) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                   ams (sLL happy_var_1 happy_var_2 $ mkUntypedSplice DollarSplice happy_var_2)-                                       [mj AnnDollar happy_var_1])}})-	) (\r -> happyReturn (happyIn221 r))--happyReduce_568 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_568 = happyMonadReduce 2# 206# happyReduction_568-happyReduction_568 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut219 happy_x_2 of { (HappyWrap219 happy_var_2) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                   ams (sLL happy_var_1 happy_var_2 $ mkTypedSplice DollarSplice happy_var_2)-                                       [mj AnnDollarDollar happy_var_1])}})-	) (\r -> happyReturn (happyIn222 r))--happyReduce_569 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_569 = happySpecReduce_2  207# happyReduction_569-happyReduction_569 happy_x_2-	happy_x_1-	 =  case happyOut223 happy_x_1 of { (HappyWrap223 happy_var_1) -> -	case happyOut224 happy_x_2 of { (HappyWrap224 happy_var_2) -> -	happyIn223-		 (happy_var_2 : happy_var_1-	)}}--happyReduce_570 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_570 = happySpecReduce_0  207# happyReduction_570-happyReduction_570  =  happyIn223-		 ([]-	)--happyReduce_571 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_571 = happyMonadReduce 1# 208# happyReduction_571-happyReduction_571 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut219 happy_x_1 of { (HappyWrap219 happy_var_1) -> -	( runECP_P happy_var_1 >>= \ cmd ->-                                    return (sL1 cmd $ HsCmdTop noExtField cmd))})-	) (\r -> happyReturn (happyIn224 r))--happyReduce_572 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_572 = happySpecReduce_3  209# happyReduction_572-happyReduction_572 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut226 happy_x_2 of { (HappyWrap226 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn225-		 (([mj AnnOpenC happy_var_1-                                                  ,mj AnnCloseC happy_var_3],happy_var_2)-	)}}}--happyReduce_573 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_573 = happySpecReduce_3  209# happyReduction_573-happyReduction_573 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut226 happy_x_2 of { (HappyWrap226 happy_var_2) -> -	happyIn225-		 (([],happy_var_2)-	)}--happyReduce_574 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_574 = happySpecReduce_1  210# happyReduction_574-happyReduction_574 happy_x_1-	 =  case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> -	happyIn226-		 (cvTopDecls happy_var_1-	)}--happyReduce_575 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_575 = happySpecReduce_1  210# happyReduction_575-happyReduction_575 happy_x_1-	 =  case happyOut75 happy_x_1 of { (HappyWrap75 happy_var_1) -> -	happyIn226-		 (cvTopDecls happy_var_1-	)}--happyReduce_576 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_576 = happySpecReduce_1  211# happyReduction_576-happyReduction_576 happy_x_1-	 =  case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> -	happyIn227-		 (happy_var_1-	)}--happyReduce_577 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_577 = happyMonadReduce 2# 211# happyReduction_577-happyReduction_577 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> -	case happyOut293 happy_x_2 of { (HappyWrap293 happy_var_2) -> -	( runECP_P happy_var_1 >>= \ happy_var_1 ->-                                runPV (rejectPragmaPV happy_var_1) >>-                                runPV happy_var_2 >>= \ happy_var_2 ->-                                return $ ecpFromExp $-                                sLL happy_var_1 happy_var_2 $ SectionL noExtField happy_var_1 happy_var_2)}})-	) (\r -> happyReturn (happyIn227 r))--happyReduce_578 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_578 = happySpecReduce_2  211# happyReduction_578-happyReduction_578 happy_x_2-	happy_x_1-	 =  case happyOut294 happy_x_1 of { (HappyWrap294 happy_var_1) -> -	case happyOut211 happy_x_2 of { (HappyWrap211 happy_var_2) -> -	happyIn227-		 (ECP $-                                superInfixOp $-                                runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                happy_var_1 >>= \ happy_var_1 ->-                                mkHsSectionR_PV (comb2 happy_var_1 happy_var_2) happy_var_1 happy_var_2-	)}}--happyReduce_579 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_579 = happySpecReduce_3  211# happyReduction_579-happyReduction_579 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> -	happyIn227-		 (ECP $-                             runECP_PV happy_var_1 >>= \ happy_var_1 ->-                             runECP_PV happy_var_3 >>= \ happy_var_3 ->-                             amms (mkHsViewPatPV (comb2 happy_var_1 happy_var_3) happy_var_1 happy_var_3) [mu AnnRarrow happy_var_2]-	)}}}--happyReduce_580 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_580 = happySpecReduce_2  212# happyReduction_580-happyReduction_580 happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOut229 happy_x_2 of { (HappyWrap229 happy_var_2) -> -	happyIn228-		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->-                             happy_var_2 >>= \ happy_var_2 ->-                             do { addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2)-                                ; return ([],Tuple ((sL1 happy_var_1 (Just happy_var_1)) : snd happy_var_2)) }-	)}}--happyReduce_581 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_581 = happySpecReduce_2  212# happyReduction_581-happyReduction_581 happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOut321 happy_x_2 of { (HappyWrap321 happy_var_2) -> -	happyIn228-		 (runECP_PV happy_var_1 >>= \ happy_var_1 -> return $-                            (mvbars (fst happy_var_2), Sum 1  (snd happy_var_2 + 1) happy_var_1)-	)}}--happyReduce_582 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_582 = happySpecReduce_2  212# happyReduction_582-happyReduction_582 happy_x_2-	happy_x_1-	 =  case happyOut319 happy_x_1 of { (HappyWrap319 happy_var_1) -> -	case happyOut230 happy_x_2 of { (HappyWrap230 happy_var_2) -> -	happyIn228-		 (happy_var_2 >>= \ happy_var_2 ->-                   do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (fst happy_var_1)-                      ; return-                           ([],Tuple (map (\l -> L l Nothing) (fst happy_var_1) ++ happy_var_2)) }-	)}}--happyReduce_583 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_583 = happySpecReduce_3  212# happyReduction_583-happyReduction_583 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> -	case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> -	case happyOut320 happy_x_3 of { (HappyWrap320 happy_var_3) -> -	happyIn228-		 (runECP_PV happy_var_2 >>= \ happy_var_2 -> return $-                  (mvbars (fst happy_var_1) ++ mvbars (fst happy_var_3), Sum (snd happy_var_1 + 1) (snd happy_var_1 + snd happy_var_3 + 1) happy_var_2)-	)}}}--happyReduce_584 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_584 = happySpecReduce_2  213# happyReduction_584-happyReduction_584 happy_x_2-	happy_x_1-	 =  case happyOut319 happy_x_1 of { (HappyWrap319 happy_var_1) -> -	case happyOut230 happy_x_2 of { (HappyWrap230 happy_var_2) -> -	happyIn229-		 (happy_var_2 >>= \ happy_var_2 ->-          do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst happy_var_1)-             ; return (-            (head $ fst happy_var_1-            ,(map (\l -> L l Nothing) (tail $ fst happy_var_1)) ++ happy_var_2)) }-	)}}--happyReduce_585 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_585 = happySpecReduce_2  214# happyReduction_585-happyReduction_585 happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOut229 happy_x_2 of { (HappyWrap229 happy_var_2) -> -	happyIn230-		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                   happy_var_2 >>= \ happy_var_2 ->-                                   addAnnotation (gl happy_var_1) AnnComma (fst happy_var_2) >>-                                   return ((L (gl happy_var_1) (Just happy_var_1)) : snd happy_var_2)-	)}}--happyReduce_586 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_586 = happySpecReduce_1  214# happyReduction_586-happyReduction_586 happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	happyIn230-		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                   return [L (gl happy_var_1) (Just happy_var_1)]-	)}--happyReduce_587 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_587 = happySpecReduce_0  214# happyReduction_587-happyReduction_587  =  happyIn230-		 (return [noLoc Nothing]-	)--happyReduce_588 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_588 = happySpecReduce_1  215# happyReduction_588-happyReduction_588 happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	happyIn231-		 (\loc -> runECP_PV happy_var_1 >>= \ happy_var_1 ->-                            mkHsExplicitListPV loc [happy_var_1]-	)}--happyReduce_589 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_589 = happySpecReduce_1  215# happyReduction_589-happyReduction_589 happy_x_1-	 =  case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> -	happyIn231-		 (\loc -> happy_var_1 >>= \ happy_var_1 ->-                            mkHsExplicitListPV loc (reverse happy_var_1)-	)}--happyReduce_590 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_590 = happySpecReduce_2  215# happyReduction_590-happyReduction_590 happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn231-		 (\loc ->    runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                  ams (L loc $ ArithSeq noExtField Nothing (From happy_var_1))-                                      [mj AnnDotdot happy_var_2]-                                      >>= ecpFromExp'-	)}}--happyReduce_591 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_591 = happyReduce 4# 215# happyReduction_591-happyReduction_591 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	happyIn231-		 (\loc ->-                                   runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                   ams (L loc $ ArithSeq noExtField Nothing (FromThen happy_var_1 happy_var_3))-                                       [mj AnnComma happy_var_2,mj AnnDotdot happy_var_4]-                                       >>= ecpFromExp'-	) `HappyStk` happyRest}}}}--happyReduce_592 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_592 = happySpecReduce_3  215# happyReduction_592-happyReduction_592 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	happyIn231-		 (\loc -> runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                   ams (L loc $ ArithSeq noExtField Nothing (FromTo happy_var_1 happy_var_3))-                                       [mj AnnDotdot happy_var_2]-                                       >>= ecpFromExp'-	)}}}--happyReduce_593 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_593 = happyReduce 5# 215# happyReduction_593-happyReduction_593 (happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	case happyOutTok happy_x_4 of { happy_var_4 -> -	case happyOut210 happy_x_5 of { (HappyWrap210 happy_var_5) -> -	happyIn231-		 (\loc ->-                                   runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                   runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                   runECP_PV happy_var_5 >>= \ happy_var_5 ->-                                   ams (L loc $ ArithSeq noExtField Nothing (FromThenTo happy_var_1 happy_var_3 happy_var_5))-                                       [mj AnnComma happy_var_2,mj AnnDotdot happy_var_4]-                                       >>= ecpFromExp'-	) `HappyStk` happyRest}}}}}--happyReduce_594 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_594 = happySpecReduce_3  215# happyReduction_594-happyReduction_594 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut233 happy_x_3 of { (HappyWrap233 happy_var_3) -> -	happyIn231-		 (\loc ->-                checkMonadComp >>= \ ctxt ->-                runECP_PV happy_var_1 >>= \ happy_var_1 ->-                ams (L loc $ mkHsComp ctxt (unLoc happy_var_3) happy_var_1)-                    [mj AnnVbar happy_var_2]-                    >>= ecpFromExp'-	)}}}--happyReduce_595 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_595 = happySpecReduce_3  216# happyReduction_595-happyReduction_595 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> -	happyIn232-		 (happy_var_1 >>= \ happy_var_1 ->-                                     runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                     addAnnotation (gl $ head $ happy_var_1)-                                                            AnnComma (gl happy_var_2) >>-                                      return (((:) $! happy_var_3) $! happy_var_1)-	)}}}--happyReduce_596 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_596 = happySpecReduce_3  216# happyReduction_596-happyReduction_596 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut227 happy_x_1 of { (HappyWrap227 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> -	happyIn232-		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                      runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                      addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>-                                      return [happy_var_3,happy_var_1]-	)}}}--happyReduce_597 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_597 = happySpecReduce_1  217# happyReduction_597-happyReduction_597 happy_x_1-	 =  case happyOut234 happy_x_1 of { (HappyWrap234 happy_var_1) -> -	happyIn233-		 (case (unLoc happy_var_1) of-                    [qs] -> sL1 happy_var_1 qs-                    -- We just had one thing in our "parallel" list so-                    -- we simply return that thing directly--                    qss -> sL1 happy_var_1 [sL1 happy_var_1 $ ParStmt noExtField [ParStmtBlock noExtField qs [] noSyntaxExpr |-                                            qs <- qss]-                                            noExpr noSyntaxExpr]-                    -- We actually found some actual parallel lists so-                    -- we wrap them into as a ParStmt-	)}--happyReduce_598 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_598 = happyMonadReduce 3# 218# happyReduction_598-happyReduction_598 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut234 happy_x_3 of { (HappyWrap234 happy_var_3) -> -	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnVbar (gl happy_var_2) >>-                        return (sLL happy_var_1 happy_var_3 (reverse (unLoc happy_var_1) : unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn234 r))--happyReduce_599 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_599 = happySpecReduce_1  218# happyReduction_599-happyReduction_599 happy_x_1-	 =  case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> -	happyIn234-		 (L (getLoc happy_var_1) [reverse (unLoc happy_var_1)]-	)}--happyReduce_600 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_600 = happyMonadReduce 3# 219# happyReduction_600-happyReduction_600 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut236 happy_x_3 of { (HappyWrap236 happy_var_3) -> -	( addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>-                amsL (comb2 happy_var_1 happy_var_3) (fst $ unLoc happy_var_3) >>-                return (sLL happy_var_1 happy_var_3 [sLL happy_var_1 happy_var_3 ((snd $ unLoc happy_var_3) (reverse (unLoc happy_var_1)))]))}}})-	) (\r -> happyReturn (happyIn235 r))--happyReduce_601 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_601 = happyMonadReduce 3# 219# happyReduction_601-happyReduction_601 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut257 happy_x_3 of { (HappyWrap257 happy_var_3) -> -	( runPV happy_var_3 >>= \ happy_var_3 ->-                addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma (gl happy_var_2) >>-                return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})-	) (\r -> happyReturn (happyIn235 r))--happyReduce_602 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_602 = happyMonadReduce 1# 219# happyReduction_602-happyReduction_602 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut236 happy_x_1 of { (HappyWrap236 happy_var_1) -> -	( ams happy_var_1 (fst $ unLoc happy_var_1) >>-                              return (sLL happy_var_1 happy_var_1 [L (getLoc happy_var_1) ((snd $ unLoc happy_var_1) [])]))})-	) (\r -> happyReturn (happyIn235 r))--happyReduce_603 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_603 = happyMonadReduce 1# 219# happyReduction_603-happyReduction_603 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> -	( runPV happy_var_1 >>= \ happy_var_1 ->-                                            return $ sL1 happy_var_1 [happy_var_1])})-	) (\r -> happyReturn (happyIn235 r))--happyReduce_604 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_604 = happyMonadReduce 2# 220# happyReduction_604-happyReduction_604 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 -> return $-                                 sLL happy_var_1 happy_var_2 ([mj AnnThen happy_var_1], \ss -> (mkTransformStmt ss happy_var_2)))}})-	) (\r -> happyReturn (happyIn236 r))--happyReduce_605 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_605 = happyMonadReduce 4# 220# happyReduction_605-happyReduction_605 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-                                 runECP_P happy_var_4 >>= \ happy_var_4 ->-                                 return $ sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnBy  happy_var_3],-                                                     \ss -> (mkTransformByStmt ss happy_var_2 happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn236 r))--happyReduce_606 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_606 = happyMonadReduce 4# 220# happyReduction_606-happyReduction_606 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	( runECP_P happy_var_4 >>= \ happy_var_4 ->-               return $ sLL happy_var_1 happy_var_4 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnUsing happy_var_3],-                                   \ss -> (mkGroupUsingStmt ss happy_var_4)))}}}})-	) (\r -> happyReturn (happyIn236 r))--happyReduce_607 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_607 = happyMonadReduce 6# 220# happyReduction_607-happyReduction_607 (happy_x_6 `HappyStk`-	happy_x_5 `HappyStk`-	happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	case happyOutTok happy_x_5 of { happy_var_5 -> -	case happyOut210 happy_x_6 of { (HappyWrap210 happy_var_6) -> -	( runECP_P happy_var_4 >>= \ happy_var_4 ->-               runECP_P happy_var_6 >>= \ happy_var_6 ->-               return $ sLL happy_var_1 happy_var_6 ([mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnBy happy_var_3,mj AnnUsing happy_var_5],-                                   \ss -> (mkGroupByUsingStmt ss happy_var_4 happy_var_6)))}}}}}})-	) (\r -> happyReturn (happyIn236 r))--happyReduce_608 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_608 = happySpecReduce_1  221# happyReduction_608-happyReduction_608 happy_x_1-	 =  case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> -	happyIn237-		 (L (getLoc happy_var_1) (reverse (unLoc happy_var_1))-	)}--happyReduce_609 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_609 = happyMonadReduce 3# 222# happyReduction_609-happyReduction_609 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut257 happy_x_3 of { (HappyWrap257 happy_var_3) -> -	( runPV happy_var_3 >>= \ happy_var_3 ->-                               addAnnotation (gl $ head $ unLoc happy_var_1) AnnComma-                                             (gl happy_var_2) >>-                               return (sLL happy_var_1 happy_var_3 (happy_var_3 : unLoc happy_var_1)))}}})-	) (\r -> happyReturn (happyIn238 r))--happyReduce_610 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_610 = happyMonadReduce 1# 222# happyReduction_610-happyReduction_610 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> -	( runPV happy_var_1 >>= \ happy_var_1 ->-                               return $ sL1 happy_var_1 [happy_var_1])})-	) (\r -> happyReturn (happyIn238 r))--happyReduce_611 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_611 = happySpecReduce_3  223# happyReduction_611-happyReduction_611 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn239-		 (happy_var_2 >>= \ happy_var_2 -> return $-                                     sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))-                                               ,(reverse (snd $ unLoc happy_var_2)))-	)}}}--happyReduce_612 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_612 = happySpecReduce_3  223# happyReduction_612-happyReduction_612 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> -	happyIn239-		 (happy_var_2 >>= \ happy_var_2 -> return $-                                       L (getLoc happy_var_2) (fst $ unLoc happy_var_2-                                        ,(reverse (snd $ unLoc happy_var_2)))-	)}--happyReduce_613 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_613 = happySpecReduce_2  223# happyReduction_613-happyReduction_613 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn239-		 (return $ sLL happy_var_1 happy_var_2 ([moc happy_var_1,mcc happy_var_2],[])-	)}}--happyReduce_614 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_614 = happySpecReduce_2  223# happyReduction_614-happyReduction_614 happy_x_2-	happy_x_1-	 =  happyIn239-		 (return $ noLoc ([],[])-	)--happyReduce_615 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_615 = happySpecReduce_1  224# happyReduction_615-happyReduction_615 happy_x_1-	 =  case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> -	happyIn240-		 (happy_var_1 >>= \ happy_var_1 -> return $-                                     sL1 happy_var_1 (fst $ unLoc happy_var_1,snd $ unLoc happy_var_1)-	)}--happyReduce_616 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_616 = happySpecReduce_2  224# happyReduction_616-happyReduction_616 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> -	happyIn240-		 (happy_var_2 >>= \ happy_var_2 -> return $-                                     sLL happy_var_1 happy_var_2 ((mj AnnSemi happy_var_1:(fst $ unLoc happy_var_2))-                                               ,snd $ unLoc happy_var_2)-	)}}--happyReduce_617 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_617 = happySpecReduce_3  225# happyReduction_617-happyReduction_617 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut242 happy_x_3 of { (HappyWrap242 happy_var_3) -> -	happyIn241-		 (happy_var_1 >>= \ happy_var_1 ->-                                  happy_var_3 >>= \ happy_var_3 ->-                                     if null (snd $ unLoc happy_var_1)-                                     then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                  ,[happy_var_3]))-                                     else (ams (head $ snd $ unLoc happy_var_1)-                                               (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))-                                           >> return (sLL happy_var_1 happy_var_3 ([],happy_var_3 : (snd $ unLoc happy_var_1))) )-	)}}}--happyReduce_618 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_618 = happySpecReduce_2  225# happyReduction_618-happyReduction_618 happy_x_2-	happy_x_1-	 =  case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn241-		 (happy_var_1 >>= \ happy_var_1 ->-                                   if null (snd $ unLoc happy_var_1)-                                     then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                  ,snd $ unLoc happy_var_1))-                                     else (ams (head $ snd $ unLoc happy_var_1)-                                               (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1))-                                           >> return (sLL happy_var_1 happy_var_2 ([],snd $ unLoc happy_var_1)))-	)}}--happyReduce_619 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_619 = happySpecReduce_1  225# happyReduction_619-happyReduction_619 happy_x_1-	 =  case happyOut242 happy_x_1 of { (HappyWrap242 happy_var_1) -> -	happyIn241-		 (happy_var_1 >>= \ happy_var_1 -> return $ sL1 happy_var_1 ([],[happy_var_1])-	)}--happyReduce_620 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_620 = happySpecReduce_2  226# happyReduction_620-happyReduction_620 happy_x_2-	happy_x_1-	 =  case happyOut248 happy_x_1 of { (HappyWrap248 happy_var_1) -> -	case happyOut243 happy_x_2 of { (HappyWrap243 happy_var_2) -> -	happyIn242-		 (happy_var_2 >>= \ happy_var_2 ->-                            ams (sLL happy_var_1 happy_var_2 (Match { m_ext = noExtField-                                                  , m_ctxt = CaseAlt-                                                  , m_pats = [happy_var_1]-                                                  , m_grhss = snd $ unLoc happy_var_2 }))-                                      (fst $ unLoc happy_var_2)-	)}}--happyReduce_621 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_621 = happySpecReduce_2  227# happyReduction_621-happyReduction_621 happy_x_2-	happy_x_1-	 =  case happyOut244 happy_x_1 of { (HappyWrap244 happy_var_1) -> -	case happyOut128 happy_x_2 of { (HappyWrap128 happy_var_2) -> -	happyIn243-		 (happy_var_1 >>= \alt ->-                                      return $ sLL alt happy_var_2 (fst $ unLoc happy_var_2, GRHSs noExtField (unLoc alt) (snd $ unLoc happy_var_2))-	)}}--happyReduce_622 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_622 = happySpecReduce_2  228# happyReduction_622-happyReduction_622 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	happyIn244-		 (runECP_PV happy_var_2 >>= \ happy_var_2 ->-                                ams (sLL happy_var_1 happy_var_2 (unguardedRHS (comb2 happy_var_1 happy_var_2) happy_var_2))-                                    [mu AnnRarrow happy_var_1]-	)}}--happyReduce_623 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_623 = happySpecReduce_1  228# happyReduction_623-happyReduction_623 happy_x_1-	 =  case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> -	happyIn244-		 (happy_var_1 >>= \gdpats ->-                                return $ sL1 gdpats (reverse (unLoc gdpats))-	)}--happyReduce_624 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_624 = happySpecReduce_2  229# happyReduction_624-happyReduction_624 happy_x_2-	happy_x_1-	 =  case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> -	case happyOut247 happy_x_2 of { (HappyWrap247 happy_var_2) -> -	happyIn245-		 (happy_var_1 >>= \gdpats ->-                         happy_var_2 >>= \gdpat ->-                         return $ sLL gdpats gdpat (gdpat : unLoc gdpats)-	)}}--happyReduce_625 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_625 = happySpecReduce_1  229# happyReduction_625-happyReduction_625 happy_x_1-	 =  case happyOut247 happy_x_1 of { (HappyWrap247 happy_var_1) -> -	happyIn245-		 (happy_var_1 >>= \gdpat -> return $ sL1 gdpat [gdpat]-	)}--happyReduce_626 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_626 = happyMonadReduce 3# 230# happyReduction_626-happyReduction_626 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut245 happy_x_2 of { (HappyWrap245 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( runPV happy_var_2 >>= \ happy_var_2 ->-                                             return $ sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3],unLoc happy_var_2))}}})-	) (\r -> happyReturn (happyIn246 r))--happyReduce_627 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_627 = happyMonadReduce 2# 230# happyReduction_627-happyReduction_627 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> -	( runPV happy_var_1 >>= \ happy_var_1 ->-                                             return $ sL1 happy_var_1 ([],unLoc happy_var_1))})-	) (\r -> happyReturn (happyIn246 r))--happyReduce_628 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_628 = happyReduce 4# 231# happyReduction_628-happyReduction_628 (happy_x_4 `HappyStk`-	happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest)-	 = case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	case happyOut210 happy_x_4 of { (HappyWrap210 happy_var_4) -> -	happyIn247-		 (runECP_PV happy_var_4 >>= \ happy_var_4 ->-                                     ams (sL (comb2 happy_var_1 happy_var_4) $ GRHS noExtField (unLoc happy_var_2) happy_var_4)-                                         [mj AnnVbar happy_var_1,mu AnnRarrow happy_var_3]-	) `HappyStk` happyRest}}}}--happyReduce_629 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_629 = happyMonadReduce 1# 232# happyReduction_629-happyReduction_629 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> -	( (checkPattern <=< runECP_P) happy_var_1)})-	) (\r -> happyReturn (happyIn248 r))--happyReduce_630 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_630 = happyMonadReduce 1# 233# happyReduction_630-happyReduction_630 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> -	( -- See Note [Parser-Validator ReaderT SDoc] in RdrHsSyn-                             checkPattern_msg (text "Possibly caused by a missing 'do'?")-                                              (runECP_PV happy_var_1))})-	) (\r -> happyReturn (happyIn249 r))--happyReduce_631 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_631 = happyMonadReduce 1# 234# happyReduction_631-happyReduction_631 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut217 happy_x_1 of { (HappyWrap217 happy_var_1) -> -	( (checkPattern <=< runECP_P) happy_var_1)})-	) (\r -> happyReturn (happyIn250 r))--happyReduce_632 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_632 = happySpecReduce_2  235# happyReduction_632-happyReduction_632 happy_x_2-	happy_x_1-	 =  case happyOut250 happy_x_1 of { (HappyWrap250 happy_var_1) -> -	case happyOut251 happy_x_2 of { (HappyWrap251 happy_var_2) -> -	happyIn251-		 (happy_var_1 : happy_var_2-	)}}--happyReduce_633 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_633 = happySpecReduce_0  235# happyReduction_633-happyReduction_633  =  happyIn251-		 ([]-	)--happyReduce_634 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_634 = happySpecReduce_3  236# happyReduction_634-happyReduction_634 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut253 happy_x_2 of { (HappyWrap253 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn252-		 (happy_var_2 >>= \ happy_var_2 -> return $-                                          sLL happy_var_1 happy_var_3 ((moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2))-                                             ,(reverse $ snd $ unLoc happy_var_2))-	)}}}--happyReduce_635 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_635 = happySpecReduce_3  236# happyReduction_635-happyReduction_635 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut253 happy_x_2 of { (HappyWrap253 happy_var_2) -> -	happyIn252-		 (happy_var_2 >>= \ happy_var_2 -> return $-                                          L (gl happy_var_2) (fst $ unLoc happy_var_2-                                                    ,reverse $ snd $ unLoc happy_var_2)-	)}--happyReduce_636 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_636 = happySpecReduce_3  237# happyReduction_636-happyReduction_636 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut256 happy_x_3 of { (HappyWrap256 happy_var_3) -> -	happyIn253-		 (happy_var_1 >>= \ happy_var_1 ->-                            happy_var_3 >>= \ happy_var_3 ->-                            if null (snd $ unLoc happy_var_1)-                              then return (sLL happy_var_1 happy_var_3 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1)-                                                     ,happy_var_3 : (snd $ unLoc happy_var_1)))-                              else do-                               { ams (head $ snd $ unLoc happy_var_1) [mj AnnSemi happy_var_2]-                               ; return $ sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1,happy_var_3 :(snd $ unLoc happy_var_1)) }-	)}}}--happyReduce_637 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_637 = happySpecReduce_2  237# happyReduction_637-happyReduction_637 happy_x_2-	happy_x_1-	 =  case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn253-		 (happy_var_1 >>= \ happy_var_1 ->-                           if null (snd $ unLoc happy_var_1)-                             then return (sLL happy_var_1 happy_var_2 (mj AnnSemi happy_var_2:(fst $ unLoc happy_var_1),snd $ unLoc happy_var_1))-                             else do-                               { ams (head $ snd $ unLoc happy_var_1)-                                               [mj AnnSemi happy_var_2]-                               ; return happy_var_1 }-	)}}--happyReduce_638 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_638 = happySpecReduce_1  237# happyReduction_638-happyReduction_638 happy_x_1-	 =  case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> -	happyIn253-		 (happy_var_1 >>= \ happy_var_1 ->-                                   return $ sL1 happy_var_1 ([],[happy_var_1])-	)}--happyReduce_639 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_639 = happySpecReduce_0  237# happyReduction_639-happyReduction_639  =  happyIn253-		 (return $ noLoc ([],[])-	)--happyReduce_640 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_640 = happyMonadReduce 1# 238# happyReduction_640-happyReduction_640 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> -	( fmap Just (runPV happy_var_1))})-	) (\r -> happyReturn (happyIn254 r))--happyReduce_641 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_641 = happySpecReduce_0  238# happyReduction_641-happyReduction_641  =  happyIn254-		 (Nothing-	)--happyReduce_642 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_642 = happyMonadReduce 1# 239# happyReduction_642-happyReduction_642 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> -	( runPV happy_var_1)})-	) (\r -> happyReturn (happyIn255 r))--happyReduce_643 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_643 = happySpecReduce_1  240# happyReduction_643-happyReduction_643 happy_x_1-	 =  case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> -	happyIn256-		 (happy_var_1-	)}--happyReduce_644 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_644 = happySpecReduce_2  240# happyReduction_644-happyReduction_644 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut252 happy_x_2 of { (HappyWrap252 happy_var_2) -> -	happyIn256-		 (happy_var_2 >>= \ happy_var_2 ->-                                           ams (sLL happy_var_1 happy_var_2 $ mkRecStmt (snd $ unLoc happy_var_2))-                                               (mj AnnRec happy_var_1:(fst $ unLoc happy_var_2))-	)}}--happyReduce_645 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_645 = happySpecReduce_3  241# happyReduction_645-happyReduction_645 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut249 happy_x_1 of { (HappyWrap249 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	happyIn257-		 (runECP_PV happy_var_3 >>= \ happy_var_3 ->-                                           ams (sLL happy_var_1 happy_var_3 $ mkBindStmt happy_var_1 happy_var_3)-                                               [mu AnnLarrow happy_var_2]-	)}}}--happyReduce_646 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_646 = happySpecReduce_1  241# happyReduction_646-happyReduction_646 happy_x_1-	 =  case happyOut210 happy_x_1 of { (HappyWrap210 happy_var_1) -> -	happyIn257-		 (runECP_PV happy_var_1 >>= \ happy_var_1 ->-                                           return $ sL1 happy_var_1 $ mkBodyStmt happy_var_1-	)}--happyReduce_647 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_647 = happySpecReduce_2  241# happyReduction_647-happyReduction_647 happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> -	happyIn257-		 (ams (sLL happy_var_1 happy_var_2 $ LetStmt noExtField (snd $ unLoc happy_var_2))-                                               (mj AnnLet happy_var_1:(fst $ unLoc happy_var_2))-	)}}--happyReduce_648 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_648 = happySpecReduce_1  242# happyReduction_648-happyReduction_648 happy_x_1-	 =  case happyOut259 happy_x_1 of { (HappyWrap259 happy_var_1) -> -	happyIn258-		 (happy_var_1-	)}--happyReduce_649 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_649 = happySpecReduce_0  242# happyReduction_649-happyReduction_649  =  happyIn258-		 (return ([],([], Nothing))-	)--happyReduce_650 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_650 = happySpecReduce_3  243# happyReduction_650-happyReduction_650 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut260 happy_x_1 of { (HappyWrap260 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut259 happy_x_3 of { (HappyWrap259 happy_var_3) -> -	happyIn259-		 (happy_var_1 >>= \ happy_var_1 ->-                   happy_var_3 >>= \ happy_var_3 ->-                   addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>-                   return (case happy_var_3 of (ma,(flds, dd)) -> (ma,(happy_var_1 : flds, dd)))-	)}}}--happyReduce_651 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_651 = happySpecReduce_1  243# happyReduction_651-happyReduction_651 happy_x_1-	 =  case happyOut260 happy_x_1 of { (HappyWrap260 happy_var_1) -> -	happyIn259-		 (happy_var_1 >>= \ happy_var_1 ->-                                          return ([],([happy_var_1], Nothing))-	)}--happyReduce_652 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_652 = happySpecReduce_1  243# happyReduction_652-happyReduction_652 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn259-		 (return ([mj AnnDotdot happy_var_1],([],   Just (getLoc happy_var_1)))-	)}--happyReduce_653 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_653 = happySpecReduce_3  244# happyReduction_653-happyReduction_653 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut227 happy_x_3 of { (HappyWrap227 happy_var_3) -> -	happyIn260-		 (runECP_PV happy_var_3 >>= \ happy_var_3 ->-                           ams  (sLL happy_var_1 happy_var_3 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) happy_var_3 False)-                                [mj AnnEqual happy_var_2]-	)}}}--happyReduce_654 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_654 = happySpecReduce_1  244# happyReduction_654-happyReduction_654 happy_x_1-	 =  case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> -	happyIn260-		 (placeHolderPunRhs >>= \rhs ->-                          return $ sLL happy_var_1 happy_var_1 $ HsRecField (sL1 happy_var_1 $ mkFieldOcc happy_var_1) rhs True-	)}--happyReduce_655 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_655 = happyMonadReduce 3# 245# happyReduction_655-happyReduction_655 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut262 happy_x_3 of { (HappyWrap262 happy_var_3) -> -	( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>-                         return (let { this = happy_var_3; rest = unLoc happy_var_1 }-                              in rest `seq` this `seq` sLL happy_var_1 happy_var_3 (this : rest)))}}})-	) (\r -> happyReturn (happyIn261 r))--happyReduce_656 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_656 = happyMonadReduce 2# 245# happyReduction_656-happyReduction_656 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( addAnnotation (gl $ last $ unLoc happy_var_1) AnnSemi (gl happy_var_2) >>-                         return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1)))}})-	) (\r -> happyReturn (happyIn261 r))--happyReduce_657 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_657 = happySpecReduce_1  245# happyReduction_657-happyReduction_657 happy_x_1-	 =  case happyOut262 happy_x_1 of { (HappyWrap262 happy_var_1) -> -	happyIn261-		 (let this = happy_var_1 in this `seq` sL1 happy_var_1 [this]-	)}--happyReduce_658 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_658 = happyMonadReduce 3# 246# happyReduction_658-happyReduction_658 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut263 happy_x_1 of { (HappyWrap263 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> -	( runECP_P happy_var_3 >>= \ happy_var_3 ->-                                          ams (sLL happy_var_1 happy_var_3 (IPBind noExtField (Left happy_var_1) happy_var_3))-                                              [mj AnnEqual happy_var_2])}}})-	) (\r -> happyReturn (happyIn262 r))--happyReduce_659 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_659 = happySpecReduce_1  247# happyReduction_659-happyReduction_659 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn263-		 (sL1 happy_var_1 (HsIPName (getIPDUPVARID happy_var_1))-	)}--happyReduce_660 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_660 = happySpecReduce_1  248# happyReduction_660-happyReduction_660 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn264-		 (sL1 happy_var_1 (getLABELVARID happy_var_1)-	)}--happyReduce_661 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_661 = happySpecReduce_1  249# happyReduction_661-happyReduction_661 happy_x_1-	 =  case happyOut266 happy_x_1 of { (HappyWrap266 happy_var_1) -> -	happyIn265-		 (happy_var_1-	)}--happyReduce_662 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_662 = happySpecReduce_0  249# happyReduction_662-happyReduction_662  =  happyIn265-		 (noLoc mkTrue-	)--happyReduce_663 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_663 = happySpecReduce_1  250# happyReduction_663-happyReduction_663 happy_x_1-	 =  case happyOut267 happy_x_1 of { (HappyWrap267 happy_var_1) -> -	happyIn266-		 (happy_var_1-	)}--happyReduce_664 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_664 = happyMonadReduce 3# 250# happyReduction_664-happyReduction_664 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut267 happy_x_1 of { (HappyWrap267 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut266 happy_x_3 of { (HappyWrap266 happy_var_3) -> -	( aa happy_var_1 (AnnVbar, happy_var_2)-                              >> return (sLL happy_var_1 happy_var_3 (Or [happy_var_1,happy_var_3])))}}})-	) (\r -> happyReturn (happyIn266 r))--happyReduce_665 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_665 = happySpecReduce_1  251# happyReduction_665-happyReduction_665 happy_x_1-	 =  case happyOut268 happy_x_1 of { (HappyWrap268 happy_var_1) -> -	happyIn267-		 (sLL (head happy_var_1) (last happy_var_1) (And (happy_var_1))-	)}--happyReduce_666 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_666 = happySpecReduce_1  252# happyReduction_666-happyReduction_666 happy_x_1-	 =  case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> -	happyIn268-		 ([happy_var_1]-	)}--happyReduce_667 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_667 = happyMonadReduce 3# 252# happyReduction_667-happyReduction_667 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut268 happy_x_3 of { (HappyWrap268 happy_var_3) -> -	( aa happy_var_1 (AnnComma, happy_var_2) >> return (happy_var_1 : happy_var_3))}}})-	) (\r -> happyReturn (happyIn268 r))--happyReduce_668 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_668 = happyMonadReduce 3# 253# happyReduction_668-happyReduction_668 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut266 happy_x_2 of { (HappyWrap266 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (Parens happy_var_2)) [mop happy_var_1,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn269 r))--happyReduce_669 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_669 = happySpecReduce_1  253# happyReduction_669-happyReduction_669 happy_x_1-	 =  case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> -	happyIn269-		 (sL1 happy_var_1 (Var happy_var_1)-	)}--happyReduce_670 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_670 = happySpecReduce_1  254# happyReduction_670-happyReduction_670 happy_x_1-	 =  case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> -	happyIn270-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_671 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_671 = happyMonadReduce 3# 254# happyReduction_671-happyReduction_671 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut270 happy_x_3 of { (HappyWrap270 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>-                                    return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn270 r))--happyReduce_672 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_672 = happySpecReduce_1  255# happyReduction_672-happyReduction_672 happy_x_1-	 =  case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> -	happyIn271-		 (happy_var_1-	)}--happyReduce_673 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_673 = happySpecReduce_1  255# happyReduction_673-happyReduction_673 happy_x_1-	 =  case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> -	happyIn271-		 (happy_var_1-	)}--happyReduce_674 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_674 = happySpecReduce_1  256# happyReduction_674-happyReduction_674 happy_x_1-	 =  case happyOut274 happy_x_1 of { (HappyWrap274 happy_var_1) -> -	happyIn272-		 (happy_var_1-	)}--happyReduce_675 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_675 = happySpecReduce_1  256# happyReduction_675-happyReduction_675 happy_x_1-	 =  case happyOut277 happy_x_1 of { (HappyWrap277 happy_var_1) -> -	happyIn272-		 (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))-	)}--happyReduce_676 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_676 = happySpecReduce_1  257# happyReduction_676-happyReduction_676 happy_x_1-	 =  case happyOut274 happy_x_1 of { (HappyWrap274 happy_var_1) -> -	happyIn273-		 (happy_var_1-	)}--happyReduce_677 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_677 = happySpecReduce_1  257# happyReduction_677-happyReduction_677 happy_x_1-	 =  case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> -	happyIn273-		 (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))-	)}--happyReduce_678 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_678 = happySpecReduce_1  258# happyReduction_678-happyReduction_678 happy_x_1-	 =  case happyOut312 happy_x_1 of { (HappyWrap312 happy_var_1) -> -	happyIn274-		 (happy_var_1-	)}--happyReduce_679 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_679 = happyMonadReduce 3# 258# happyReduction_679-happyReduction_679 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut314 happy_x_2 of { (HappyWrap314 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                   [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn274 r))--happyReduce_680 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_680 = happySpecReduce_1  259# happyReduction_680-happyReduction_680 happy_x_1-	 =  case happyOut313 happy_x_1 of { (HappyWrap313 happy_var_1) -> -	happyIn275-		 (happy_var_1-	)}--happyReduce_681 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_681 = happyMonadReduce 3# 259# happyReduction_681-happyReduction_681 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut315 happy_x_2 of { (HappyWrap315 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn275 r))--happyReduce_682 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_682 = happySpecReduce_1  259# happyReduction_682-happyReduction_682 happy_x_1-	 =  case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> -	happyIn275-		 (sL1 happy_var_1 $ nameRdrName (dataConName (unLoc happy_var_1))-	)}--happyReduce_683 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_683 = happySpecReduce_1  260# happyReduction_683-happyReduction_683 happy_x_1-	 =  case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> -	happyIn276-		 (sL1 happy_var_1 [happy_var_1]-	)}--happyReduce_684 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_684 = happyMonadReduce 3# 260# happyReduction_684-happyReduction_684 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOut276 happy_x_3 of { (HappyWrap276 happy_var_3) -> -	( addAnnotation (gl happy_var_1) AnnComma (gl happy_var_2) >>-                                   return (sLL happy_var_1 happy_var_3 (happy_var_1 : unLoc happy_var_3)))}}})-	) (\r -> happyReturn (happyIn276 r))--happyReduce_685 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_685 = happyMonadReduce 2# 261# happyReduction_685-happyReduction_685 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 unitDataCon) [mop happy_var_1,mcp happy_var_2])}})-	) (\r -> happyReturn (happyIn277 r))--happyReduce_686 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_686 = happyMonadReduce 3# 261# happyReduction_686-happyReduction_686 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Boxed (snd happy_var_2 + 1))-                                       (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})-	) (\r -> happyReturn (happyIn277 r))--happyReduce_687 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_687 = happyMonadReduce 2# 261# happyReduction_687-happyReduction_687 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 $ unboxedUnitDataCon) [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn277 r))--happyReduce_688 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_688 = happyMonadReduce 3# 261# happyReduction_688-happyReduction_688 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ tupleDataCon Unboxed (snd happy_var_2 + 1))-                                       (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})-	) (\r -> happyReturn (happyIn277 r))--happyReduce_689 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_689 = happySpecReduce_1  262# happyReduction_689-happyReduction_689 happy_x_1-	 =  case happyOut277 happy_x_1 of { (HappyWrap277 happy_var_1) -> -	happyIn278-		 (happy_var_1-	)}--happyReduce_690 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_690 = happyMonadReduce 2# 262# happyReduction_690-happyReduction_690 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 nilDataCon) [mos happy_var_1,mcs happy_var_2])}})-	) (\r -> happyReturn (happyIn278 r))--happyReduce_691 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_691 = happySpecReduce_1  263# happyReduction_691-happyReduction_691 happy_x_1-	 =  case happyOut315 happy_x_1 of { (HappyWrap315 happy_var_1) -> -	happyIn279-		 (happy_var_1-	)}--happyReduce_692 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_692 = happyMonadReduce 3# 263# happyReduction_692-happyReduction_692 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut313 happy_x_2 of { (HappyWrap313 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn279 r))--happyReduce_693 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_693 = happySpecReduce_1  264# happyReduction_693-happyReduction_693 happy_x_1-	 =  case happyOut314 happy_x_1 of { (HappyWrap314 happy_var_1) -> -	happyIn280-		 (happy_var_1-	)}--happyReduce_694 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_694 = happyMonadReduce 3# 264# happyReduction_694-happyReduction_694 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut312 happy_x_2 of { (HappyWrap312 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn280 r))--happyReduce_695 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_695 = happySpecReduce_1  265# happyReduction_695-happyReduction_695 happy_x_1-	 =  case happyOut282 happy_x_1 of { (HappyWrap282 happy_var_1) -> -	happyIn281-		 (happy_var_1-	)}--happyReduce_696 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_696 = happyMonadReduce 2# 265# happyReduction_696-happyReduction_696 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 $ getRdrName unitTyCon)-                                              [mop happy_var_1,mcp happy_var_2])}})-	) (\r -> happyReturn (happyIn281 r))--happyReduce_697 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_697 = happyMonadReduce 2# 265# happyReduction_697-happyReduction_697 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 $ getRdrName unboxedUnitTyCon)-                                              [mo happy_var_1,mc happy_var_2])}})-	) (\r -> happyReturn (happyIn281 r))--happyReduce_698 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_698 = happySpecReduce_1  266# happyReduction_698-happyReduction_698 happy_x_1-	 =  case happyOut283 happy_x_1 of { (HappyWrap283 happy_var_1) -> -	happyIn282-		 (happy_var_1-	)}--happyReduce_699 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_699 = happyMonadReduce 3# 266# happyReduction_699-happyReduction_699 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Boxed-                                                        (snd happy_var_2 + 1)))-                                       (mop happy_var_1:mcp happy_var_3:(mcommas (fst happy_var_2))))}}})-	) (\r -> happyReturn (happyIn282 r))--happyReduce_700 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_700 = happyMonadReduce 3# 266# happyReduction_700-happyReduction_700 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut319 happy_x_2 of { (HappyWrap319 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Unboxed-                                                        (snd happy_var_2 + 1)))-                                       (mo happy_var_1:mc happy_var_3:(mcommas (fst happy_var_2))))}}})-	) (\r -> happyReturn (happyIn282 r))--happyReduce_701 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_701 = happyMonadReduce 3# 266# happyReduction_701-happyReduction_701 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 $ getRdrName funTyCon)-                                       [mop happy_var_1,mu AnnRarrow happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn282 r))--happyReduce_702 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_702 = happyMonadReduce 2# 266# happyReduction_702-happyReduction_702 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	( ams (sLL happy_var_1 happy_var_2 $ listTyCon_RDR) [mos happy_var_1,mcs happy_var_2])}})-	) (\r -> happyReturn (happyIn282 r))--happyReduce_703 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_703 = happySpecReduce_1  267# happyReduction_703-happyReduction_703 happy_x_1-	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> -	happyIn283-		 (happy_var_1-	)}--happyReduce_704 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_704 = happyMonadReduce 3# 267# happyReduction_704-happyReduction_704 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut289 happy_x_2 of { (HappyWrap289 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                               [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn283 r))--happyReduce_705 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_705 = happySpecReduce_1  268# happyReduction_705-happyReduction_705 happy_x_1-	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> -	happyIn284-		 (happy_var_1-	)}--happyReduce_706 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_706 = happyMonadReduce 3# 268# happyReduction_706-happyReduction_706 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( let { name :: Located RdrName-                                    ; name = sL1 happy_var_2 $! mkQual tcClsName (getQCONSYM happy_var_2) }-                                in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn284 r))--happyReduce_707 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_707 = happyMonadReduce 3# 268# happyReduction_707-happyReduction_707 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( let { name :: Located RdrName-                                    ; name = sL1 happy_var_2 $! mkUnqual tcClsName (getCONSYM happy_var_2) }-                                in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn284 r))--happyReduce_708 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_708 = happyMonadReduce 3# 268# happyReduction_708-happyReduction_708 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( let { name :: Located RdrName-                                    ; name = sL1 happy_var_2 $! consDataCon_RDR }-                                in ams (sLL happy_var_1 happy_var_3 (unLoc name)) [mop happy_var_1,mj AnnVal name,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn284 r))--happyReduce_709 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_709 = happySpecReduce_1  269# happyReduction_709-happyReduction_709 happy_x_1-	 =  case happyOut289 happy_x_1 of { (HappyWrap289 happy_var_1) -> -	happyIn285-		 (happy_var_1-	)}--happyReduce_710 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_710 = happyMonadReduce 3# 269# happyReduction_710-happyReduction_710 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut286 happy_x_2 of { (HappyWrap286 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                               [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                               ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn285 r))--happyReduce_711 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_711 = happySpecReduce_1  270# happyReduction_711-happyReduction_711 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn286-		 (sL1 happy_var_1 $! mkQual tcClsName (getQCONID happy_var_1)-	)}--happyReduce_712 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_712 = happySpecReduce_1  270# happyReduction_712-happyReduction_712 happy_x_1-	 =  case happyOut288 happy_x_1 of { (HappyWrap288 happy_var_1) -> -	happyIn286-		 (happy_var_1-	)}--happyReduce_713 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_713 = happySpecReduce_1  271# happyReduction_713-happyReduction_713 happy_x_1-	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> -	happyIn287-		 (sL1 happy_var_1                           (HsTyVar noExtField NotPromoted happy_var_1)-	)}--happyReduce_714 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_714 = happySpecReduce_2  271# happyReduction_714-happyReduction_714 happy_x_2-	happy_x_1-	 =  case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> -	case happyOut323 happy_x_2 of { (HappyWrap323 happy_var_2) -> -	happyIn287-		 (sLL happy_var_1 happy_var_2 (HsDocTy noExtField (sL1 happy_var_1 (HsTyVar noExtField NotPromoted happy_var_1)) happy_var_2)-	)}}--happyReduce_715 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_715 = happySpecReduce_1  272# happyReduction_715-happyReduction_715 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn288-		 (sL1 happy_var_1 $! mkUnqual tcClsName (getCONID happy_var_1)-	)}--happyReduce_716 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_716 = happySpecReduce_1  273# happyReduction_716-happyReduction_716 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn289-		 (sL1 happy_var_1 $! mkQual tcClsName (getQCONSYM happy_var_1)-	)}--happyReduce_717 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_717 = happySpecReduce_1  273# happyReduction_717-happyReduction_717 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn289-		 (sL1 happy_var_1 $! mkQual tcClsName (getQVARSYM happy_var_1)-	)}--happyReduce_718 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_718 = happySpecReduce_1  273# happyReduction_718-happyReduction_718 happy_x_1-	 =  case happyOut290 happy_x_1 of { (HappyWrap290 happy_var_1) -> -	happyIn289-		 (happy_var_1-	)}--happyReduce_719 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_719 = happySpecReduce_1  274# happyReduction_719-happyReduction_719 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn290-		 (sL1 happy_var_1 $! mkUnqual tcClsName (getCONSYM happy_var_1)-	)}--happyReduce_720 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_720 = happySpecReduce_1  274# happyReduction_720-happyReduction_720 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn290-		 (sL1 happy_var_1 $!-                                    -- See Note [eqTyCon (~) is built-in syntax] in TysWiredIn-                                    if getVARSYM happy_var_1 == fsLit "~"-                                      then eqTyCon_RDR-                                      else mkUnqual tcClsName (getVARSYM happy_var_1)-	)}--happyReduce_721 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_721 = happySpecReduce_1  274# happyReduction_721-happyReduction_721 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn290-		 (sL1 happy_var_1 $! consDataCon_RDR-	)}--happyReduce_722 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_722 = happySpecReduce_1  274# happyReduction_722-happyReduction_722 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn290-		 (sL1 happy_var_1 $! mkUnqual tcClsName (fsLit "-")-	)}--happyReduce_723 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_723 = happySpecReduce_1  274# happyReduction_723-happyReduction_723 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn290-		 (sL1 happy_var_1 $! mkUnqual tcClsName (fsLit ".")-	)}--happyReduce_724 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_724 = happySpecReduce_1  275# happyReduction_724-happyReduction_724 happy_x_1-	 =  case happyOut292 happy_x_1 of { (HappyWrap292 happy_var_1) -> -	happyIn291-		 (happy_var_1-	)}--happyReduce_725 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_725 = happySpecReduce_1  275# happyReduction_725-happyReduction_725 happy_x_1-	 =  case happyOut279 happy_x_1 of { (HappyWrap279 happy_var_1) -> -	happyIn291-		 (happy_var_1-	)}--happyReduce_726 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_726 = happySpecReduce_1  275# happyReduction_726-happyReduction_726 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn291-		 (sL1 happy_var_1 $ getRdrName funTyCon-	)}--happyReduce_727 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_727 = happySpecReduce_1  276# happyReduction_727-happyReduction_727 happy_x_1-	 =  case happyOut308 happy_x_1 of { (HappyWrap308 happy_var_1) -> -	happyIn292-		 (happy_var_1-	)}--happyReduce_728 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_728 = happyMonadReduce 3# 276# happyReduction_728-happyReduction_728 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut304 happy_x_2 of { (HappyWrap304 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn292 r))--happyReduce_729 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_729 = happySpecReduce_1  277# happyReduction_729-happyReduction_729 happy_x_1-	 =  case happyOut296 happy_x_1 of { (HappyWrap296 happy_var_1) -> -	happyIn293-		 (mkHsVarOpPV happy_var_1-	)}--happyReduce_730 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_730 = happySpecReduce_1  277# happyReduction_730-happyReduction_730 happy_x_1-	 =  case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> -	happyIn293-		 (mkHsConOpPV happy_var_1-	)}--happyReduce_731 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_731 = happySpecReduce_1  277# happyReduction_731-happyReduction_731 happy_x_1-	 =  case happyOut295 happy_x_1 of { (HappyWrap295 happy_var_1) -> -	happyIn293-		 (happy_var_1-	)}--happyReduce_732 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_732 = happySpecReduce_1  278# happyReduction_732-happyReduction_732 happy_x_1-	 =  case happyOut297 happy_x_1 of { (HappyWrap297 happy_var_1) -> -	happyIn294-		 (mkHsVarOpPV happy_var_1-	)}--happyReduce_733 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_733 = happySpecReduce_1  278# happyReduction_733-happyReduction_733 happy_x_1-	 =  case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> -	happyIn294-		 (mkHsConOpPV happy_var_1-	)}--happyReduce_734 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_734 = happySpecReduce_1  278# happyReduction_734-happyReduction_734 happy_x_1-	 =  case happyOut295 happy_x_1 of { (HappyWrap295 happy_var_1) -> -	happyIn294-		 (happy_var_1-	)}--happyReduce_735 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_735 = happySpecReduce_3  279# happyReduction_735-happyReduction_735 happy_x_3-	happy_x_2-	happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	happyIn295-		 (amms (mkHsInfixHolePV (comb2 happy_var_1 happy_var_3))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3]-	)}}}--happyReduce_736 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_736 = happySpecReduce_1  280# happyReduction_736-happyReduction_736 happy_x_1-	 =  case happyOut305 happy_x_1 of { (HappyWrap305 happy_var_1) -> -	happyIn296-		 (happy_var_1-	)}--happyReduce_737 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_737 = happyMonadReduce 3# 280# happyReduction_737-happyReduction_737 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut303 happy_x_2 of { (HappyWrap303 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn296 r))--happyReduce_738 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_738 = happySpecReduce_1  281# happyReduction_738-happyReduction_738 happy_x_1-	 =  case happyOut306 happy_x_1 of { (HappyWrap306 happy_var_1) -> -	happyIn297-		 (happy_var_1-	)}--happyReduce_739 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_739 = happyMonadReduce 3# 281# happyReduction_739-happyReduction_739 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut303 happy_x_2 of { (HappyWrap303 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn297 r))--happyReduce_740 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_740 = happySpecReduce_1  282# happyReduction_740-happyReduction_740 happy_x_1-	 =  case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> -	happyIn298-		 (happy_var_1-	)}--happyReduce_741 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_741 = happyMonadReduce 3# 283# happyReduction_741-happyReduction_741 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mj AnnBackquote happy_var_1,mj AnnVal happy_var_2-                                       ,mj AnnBackquote happy_var_3])}}})-	) (\r -> happyReturn (happyIn299 r))--happyReduce_742 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_742 = happySpecReduce_1  284# happyReduction_742-happyReduction_742 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn300-		 (sL1 happy_var_1 $! mkUnqual tvName (getVARID happy_var_1)-	)}--happyReduce_743 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_743 = happySpecReduce_1  284# happyReduction_743-happyReduction_743 happy_x_1-	 =  case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> -	happyIn300-		 (sL1 happy_var_1 $! mkUnqual tvName (unLoc happy_var_1)-	)}--happyReduce_744 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_744 = happySpecReduce_1  284# happyReduction_744-happyReduction_744 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn300-		 (sL1 happy_var_1 $! mkUnqual tvName (fsLit "unsafe")-	)}--happyReduce_745 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_745 = happySpecReduce_1  284# happyReduction_745-happyReduction_745 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn300-		 (sL1 happy_var_1 $! mkUnqual tvName (fsLit "safe")-	)}--happyReduce_746 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_746 = happySpecReduce_1  284# happyReduction_746-happyReduction_746 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn300-		 (sL1 happy_var_1 $! mkUnqual tvName (fsLit "interruptible")-	)}--happyReduce_747 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_747 = happySpecReduce_1  285# happyReduction_747-happyReduction_747 happy_x_1-	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> -	happyIn301-		 (happy_var_1-	)}--happyReduce_748 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_748 = happyMonadReduce 3# 285# happyReduction_748-happyReduction_748 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut308 happy_x_2 of { (HappyWrap308 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn301 r))--happyReduce_749 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_749 = happySpecReduce_1  286# happyReduction_749-happyReduction_749 happy_x_1-	 =  case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> -	happyIn302-		 (happy_var_1-	)}--happyReduce_750 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_750 = happyMonadReduce 3# 286# happyReduction_750-happyReduction_750 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut308 happy_x_2 of { (HappyWrap308 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn302 r))--happyReduce_751 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_751 = happyMonadReduce 3# 286# happyReduction_751-happyReduction_751 (happy_x_3 `HappyStk`-	happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	case happyOut307 happy_x_2 of { (HappyWrap307 happy_var_2) -> -	case happyOutTok happy_x_3 of { happy_var_3 -> -	( ams (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))-                                       [mop happy_var_1,mj AnnVal happy_var_2,mcp happy_var_3])}}})-	) (\r -> happyReturn (happyIn302 r))--happyReduce_752 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_752 = happySpecReduce_1  287# happyReduction_752-happyReduction_752 happy_x_1-	 =  case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> -	happyIn303-		 (happy_var_1-	)}--happyReduce_753 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_753 = happySpecReduce_1  287# happyReduction_753-happyReduction_753 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn303-		 (sL1 happy_var_1 $! mkQual varName (getQVARID happy_var_1)-	)}--happyReduce_754 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_754 = happySpecReduce_1  288# happyReduction_754-happyReduction_754 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (getVARID happy_var_1)-	)}--happyReduce_755 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_755 = happySpecReduce_1  288# happyReduction_755-happyReduction_755 happy_x_1-	 =  case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (unLoc happy_var_1)-	)}--happyReduce_756 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_756 = happySpecReduce_1  288# happyReduction_756-happyReduction_756 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "unsafe")-	)}--happyReduce_757 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_757 = happySpecReduce_1  288# happyReduction_757-happyReduction_757 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "safe")-	)}--happyReduce_758 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_758 = happySpecReduce_1  288# happyReduction_758-happyReduction_758 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "interruptible")-	)}--happyReduce_759 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_759 = happySpecReduce_1  288# happyReduction_759-happyReduction_759 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "forall")-	)}--happyReduce_760 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_760 = happySpecReduce_1  288# happyReduction_760-happyReduction_760 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "family")-	)}--happyReduce_761 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_761 = happySpecReduce_1  288# happyReduction_761-happyReduction_761 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn304-		 (sL1 happy_var_1 $! mkUnqual varName (fsLit "role")-	)}--happyReduce_762 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_762 = happySpecReduce_1  289# happyReduction_762-happyReduction_762 happy_x_1-	 =  case happyOut308 happy_x_1 of { (HappyWrap308 happy_var_1) -> -	happyIn305-		 (happy_var_1-	)}--happyReduce_763 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_763 = happySpecReduce_1  289# happyReduction_763-happyReduction_763 happy_x_1-	 =  case happyOut307 happy_x_1 of { (HappyWrap307 happy_var_1) -> -	happyIn305-		 (happy_var_1-	)}--happyReduce_764 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_764 = happySpecReduce_1  290# happyReduction_764-happyReduction_764 happy_x_1-	 =  case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> -	happyIn306-		 (happy_var_1-	)}--happyReduce_765 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_765 = happySpecReduce_1  290# happyReduction_765-happyReduction_765 happy_x_1-	 =  case happyOut307 happy_x_1 of { (HappyWrap307 happy_var_1) -> -	happyIn306-		 (happy_var_1-	)}--happyReduce_766 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_766 = happySpecReduce_1  291# happyReduction_766-happyReduction_766 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn307-		 (sL1 happy_var_1 $ mkQual varName (getQVARSYM happy_var_1)-	)}--happyReduce_767 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_767 = happySpecReduce_1  292# happyReduction_767-happyReduction_767 happy_x_1-	 =  case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> -	happyIn308-		 (happy_var_1-	)}--happyReduce_768 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_768 = happySpecReduce_1  292# happyReduction_768-happyReduction_768 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn308-		 (sL1 happy_var_1 $ mkUnqual varName (fsLit "-")-	)}--happyReduce_769 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_769 = happySpecReduce_1  293# happyReduction_769-happyReduction_769 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn309-		 (sL1 happy_var_1 $ mkUnqual varName (getVARSYM happy_var_1)-	)}--happyReduce_770 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_770 = happySpecReduce_1  293# happyReduction_770-happyReduction_770 happy_x_1-	 =  case happyOut311 happy_x_1 of { (HappyWrap311 happy_var_1) -> -	happyIn309-		 (sL1 happy_var_1 $ mkUnqual varName (unLoc happy_var_1)-	)}--happyReduce_771 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_771 = happySpecReduce_1  294# happyReduction_771-happyReduction_771 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "as")-	)}--happyReduce_772 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_772 = happySpecReduce_1  294# happyReduction_772-happyReduction_772 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "qualified")-	)}--happyReduce_773 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_773 = happySpecReduce_1  294# happyReduction_773-happyReduction_773 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "hiding")-	)}--happyReduce_774 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_774 = happySpecReduce_1  294# happyReduction_774-happyReduction_774 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "export")-	)}--happyReduce_775 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_775 = happySpecReduce_1  294# happyReduction_775-happyReduction_775 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "label")-	)}--happyReduce_776 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_776 = happySpecReduce_1  294# happyReduction_776-happyReduction_776 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "dynamic")-	)}--happyReduce_777 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_777 = happySpecReduce_1  294# happyReduction_777-happyReduction_777 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "stdcall")-	)}--happyReduce_778 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_778 = happySpecReduce_1  294# happyReduction_778-happyReduction_778 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "ccall")-	)}--happyReduce_779 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_779 = happySpecReduce_1  294# happyReduction_779-happyReduction_779 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "capi")-	)}--happyReduce_780 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_780 = happySpecReduce_1  294# happyReduction_780-happyReduction_780 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "prim")-	)}--happyReduce_781 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_781 = happySpecReduce_1  294# happyReduction_781-happyReduction_781 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "javascript")-	)}--happyReduce_782 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_782 = happySpecReduce_1  294# happyReduction_782-happyReduction_782 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "group")-	)}--happyReduce_783 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_783 = happySpecReduce_1  294# happyReduction_783-happyReduction_783 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "stock")-	)}--happyReduce_784 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_784 = happySpecReduce_1  294# happyReduction_784-happyReduction_784 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "anyclass")-	)}--happyReduce_785 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_785 = happySpecReduce_1  294# happyReduction_785-happyReduction_785 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "via")-	)}--happyReduce_786 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_786 = happySpecReduce_1  294# happyReduction_786-happyReduction_786 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "unit")-	)}--happyReduce_787 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_787 = happySpecReduce_1  294# happyReduction_787-happyReduction_787 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "dependency")-	)}--happyReduce_788 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_788 = happySpecReduce_1  294# happyReduction_788-happyReduction_788 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn310-		 (sL1 happy_var_1 (fsLit "signature")-	)}--happyReduce_789 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_789 = happySpecReduce_1  295# happyReduction_789-happyReduction_789 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn311-		 (sL1 happy_var_1 (fsLit ".")-	)}--happyReduce_790 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_790 = happySpecReduce_1  295# happyReduction_790-happyReduction_790 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn311-		 (sL1 happy_var_1 (fsLit (starSym (isUnicode happy_var_1)))-	)}--happyReduce_791 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_791 = happySpecReduce_1  296# happyReduction_791-happyReduction_791 happy_x_1-	 =  case happyOut313 happy_x_1 of { (HappyWrap313 happy_var_1) -> -	happyIn312-		 (happy_var_1-	)}--happyReduce_792 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_792 = happySpecReduce_1  296# happyReduction_792-happyReduction_792 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn312-		 (sL1 happy_var_1 $! mkQual dataName (getQCONID happy_var_1)-	)}--happyReduce_793 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_793 = happySpecReduce_1  297# happyReduction_793-happyReduction_793 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn313-		 (sL1 happy_var_1 $ mkUnqual dataName (getCONID happy_var_1)-	)}--happyReduce_794 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_794 = happySpecReduce_1  298# happyReduction_794-happyReduction_794 happy_x_1-	 =  case happyOut315 happy_x_1 of { (HappyWrap315 happy_var_1) -> -	happyIn314-		 (happy_var_1-	)}--happyReduce_795 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_795 = happySpecReduce_1  298# happyReduction_795-happyReduction_795 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn314-		 (sL1 happy_var_1 $ mkQual dataName (getQCONSYM happy_var_1)-	)}--happyReduce_796 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_796 = happySpecReduce_1  299# happyReduction_796-happyReduction_796 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn315-		 (sL1 happy_var_1 $ mkUnqual dataName (getCONSYM happy_var_1)-	)}--happyReduce_797 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_797 = happySpecReduce_1  299# happyReduction_797-happyReduction_797 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn315-		 (sL1 happy_var_1 $ consDataCon_RDR-	)}--happyReduce_798 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_798 = happySpecReduce_1  300# happyReduction_798-happyReduction_798 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsChar       (getCHARs happy_var_1) $ getCHAR happy_var_1-	)}--happyReduce_799 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_799 = happySpecReduce_1  300# happyReduction_799-happyReduction_799 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsString     (getSTRINGs happy_var_1)-                                                    $ getSTRING happy_var_1-	)}--happyReduce_800 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_800 = happySpecReduce_1  300# happyReduction_800-happyReduction_800 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsIntPrim    (getPRIMINTEGERs happy_var_1)-                                                    $ getPRIMINTEGER happy_var_1-	)}--happyReduce_801 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_801 = happySpecReduce_1  300# happyReduction_801-happyReduction_801 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsWordPrim   (getPRIMWORDs happy_var_1)-                                                    $ getPRIMWORD happy_var_1-	)}--happyReduce_802 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_802 = happySpecReduce_1  300# happyReduction_802-happyReduction_802 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsCharPrim   (getPRIMCHARs happy_var_1)-                                                    $ getPRIMCHAR happy_var_1-	)}--happyReduce_803 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_803 = happySpecReduce_1  300# happyReduction_803-happyReduction_803 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsStringPrim (getPRIMSTRINGs happy_var_1)-                                                    $ getPRIMSTRING happy_var_1-	)}--happyReduce_804 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_804 = happySpecReduce_1  300# happyReduction_804-happyReduction_804 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsFloatPrim  noExtField $ getPRIMFLOAT happy_var_1-	)}--happyReduce_805 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_805 = happySpecReduce_1  300# happyReduction_805-happyReduction_805 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn316-		 (sL1 happy_var_1 $ HsDoublePrim noExtField $ getPRIMDOUBLE happy_var_1-	)}--happyReduce_806 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_806 = happySpecReduce_1  301# happyReduction_806-happyReduction_806 happy_x_1-	 =  happyIn317-		 (()-	)--happyReduce_807 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_807 = happyMonadReduce 1# 301# happyReduction_807-happyReduction_807 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((( popContext))-	) (\r -> happyReturn (happyIn317 r))--happyReduce_808 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_808 = happySpecReduce_1  302# happyReduction_808-happyReduction_808 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn318-		 (sL1 happy_var_1 $ mkModuleNameFS (getCONID happy_var_1)-	)}--happyReduce_809 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_809 = happySpecReduce_1  302# happyReduction_809-happyReduction_809 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn318-		 (sL1 happy_var_1 $ let (mod,c) = getQCONID happy_var_1 in-                                  mkModuleNameFS-                                   (mkFastString-                                     (unpackFS mod ++ '.':unpackFS c))-	)}--happyReduce_810 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_810 = happySpecReduce_2  303# happyReduction_810-happyReduction_810 happy_x_2-	happy_x_1-	 =  case happyOut319 happy_x_1 of { (HappyWrap319 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn319-		 (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)-	)}}--happyReduce_811 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_811 = happySpecReduce_1  303# happyReduction_811-happyReduction_811 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn319-		 (([gl happy_var_1],1)-	)}--happyReduce_812 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_812 = happySpecReduce_1  304# happyReduction_812-happyReduction_812 happy_x_1-	 =  case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> -	happyIn320-		 (happy_var_1-	)}--happyReduce_813 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_813 = happySpecReduce_0  304# happyReduction_813-happyReduction_813  =  happyIn320-		 (([], 0)-	)--happyReduce_814 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_814 = happySpecReduce_2  305# happyReduction_814-happyReduction_814 happy_x_2-	happy_x_1-	 =  case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> -	case happyOutTok happy_x_2 of { happy_var_2 -> -	happyIn321-		 (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)-	)}}--happyReduce_815 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_815 = happySpecReduce_1  305# happyReduction_815-happyReduction_815 happy_x_1-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> -	happyIn321-		 (([gl happy_var_1],1)-	)}--happyReduce_816 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_816 = happyMonadReduce 1# 306# happyReduction_816-happyReduction_816 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( return (sL1 happy_var_1 (mkHsDocString (getDOCNEXT happy_var_1))))})-	) (\r -> happyReturn (happyIn322 r))--happyReduce_817 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_817 = happyMonadReduce 1# 307# happyReduction_817-happyReduction_817 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( return (sL1 happy_var_1 (mkHsDocString (getDOCPREV happy_var_1))))})-	) (\r -> happyReturn (happyIn323 r))--happyReduce_818 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_818 = happyMonadReduce 1# 308# happyReduction_818-happyReduction_818 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	(-      let string = getDOCNAMED happy_var_1-          (name, rest) = break isSpace string-      in return (sL1 happy_var_1 (name, mkHsDocString rest)))})-	) (\r -> happyReturn (happyIn324 r))--happyReduce_819 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_819 = happyMonadReduce 1# 309# happyReduction_819-happyReduction_819 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( let (n, doc) = getDOCSECTION happy_var_1 in-        return (sL1 happy_var_1 (n, mkHsDocString doc)))})-	) (\r -> happyReturn (happyIn325 r))--happyReduce_820 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_820 = happyMonadReduce 1# 310# happyReduction_820-happyReduction_820 (happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> -	( let string = getDOCNEXT happy_var_1 in-                     return (Just (sL1 happy_var_1 (mkHsDocString string))))})-	) (\r -> happyReturn (happyIn326 r))--happyReduce_821 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_821 = happySpecReduce_1  311# happyReduction_821-happyReduction_821 happy_x_1-	 =  case happyOut323 happy_x_1 of { (HappyWrap323 happy_var_1) -> -	happyIn327-		 (Just happy_var_1-	)}--happyReduce_822 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_822 = happySpecReduce_0  311# happyReduction_822-happyReduction_822  =  happyIn327-		 (Nothing-	)--happyReduce_823 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_823 = happySpecReduce_1  312# happyReduction_823-happyReduction_823 happy_x_1-	 =  case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> -	happyIn328-		 (Just happy_var_1-	)}--happyReduce_824 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_824 = happySpecReduce_0  312# happyReduction_824-happyReduction_824  =  happyIn328-		 (Nothing-	)--happyReduce_825 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_825 = happyMonadReduce 2# 313# happyReduction_825-happyReduction_825 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut215 happy_x_1 of { (HappyWrap215 happy_var_1) -> -	case happyOut210 happy_x_2 of { (HappyWrap210 happy_var_2) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-         fmap ecpFromExp $-         ams (sLL happy_var_1 happy_var_2 $ HsPragE noExtField (snd $ unLoc happy_var_1) happy_var_2)-             (fst $ unLoc happy_var_1))}})-	) (\r -> happyReturn (happyIn329 r))--happyReduce_826 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_826 = happyMonadReduce 2# 314# happyReduction_826-happyReduction_826 (happy_x_2 `HappyStk`-	happy_x_1 `HappyStk`-	happyRest) tk-	 = happyThen ((case happyOut215 happy_x_1 of { (HappyWrap215 happy_var_1) -> -	case happyOut212 happy_x_2 of { (HappyWrap212 happy_var_2) -> -	( runECP_P happy_var_2 >>= \ happy_var_2 ->-         fmap ecpFromExp $-         ams (sLL happy_var_1 happy_var_2 $ HsPragE noExtField (snd $ unLoc happy_var_1) happy_var_2)-             (fst $ unLoc happy_var_1))}})-	) (\r -> happyReturn (happyIn330 r))--happyNewToken action sts stk-	= (lexer True)(\tk -> -	let cont i = happyDoAction i tk action sts stk in-	case tk of {-	L _ ITeof -> happyDoAction 149# tk action sts stk;-	L _ ITunderscore -> cont 1#;-	L _ ITas -> cont 2#;-	L _ ITcase -> cont 3#;-	L _ ITclass -> cont 4#;-	L _ ITdata -> cont 5#;-	L _ ITdefault -> cont 6#;-	L _ ITderiving -> cont 7#;-	L _ ITdo -> cont 8#;-	L _ ITelse -> cont 9#;-	L _ IThiding -> cont 10#;-	L _ ITif -> cont 11#;-	L _ ITimport -> cont 12#;-	L _ ITin -> cont 13#;-	L _ ITinfix -> cont 14#;-	L _ ITinfixl -> cont 15#;-	L _ ITinfixr -> cont 16#;-	L _ ITinstance -> cont 17#;-	L _ ITlet -> cont 18#;-	L _ ITmodule -> cont 19#;-	L _ ITnewtype -> cont 20#;-	L _ ITof -> cont 21#;-	L _ ITqualified -> cont 22#;-	L _ ITthen -> cont 23#;-	L _ ITtype -> cont 24#;-	L _ ITwhere -> cont 25#;-	L _ (ITforall _) -> cont 26#;-	L _ ITforeign -> cont 27#;-	L _ ITexport -> cont 28#;-	L _ ITlabel -> cont 29#;-	L _ ITdynamic -> cont 30#;-	L _ ITsafe -> cont 31#;-	L _ ITinterruptible -> cont 32#;-	L _ ITunsafe -> cont 33#;-	L _ ITmdo -> cont 34#;-	L _ ITfamily -> cont 35#;-	L _ ITrole -> cont 36#;-	L _ ITstdcallconv -> cont 37#;-	L _ ITccallconv -> cont 38#;-	L _ ITcapiconv -> cont 39#;-	L _ ITprimcallconv -> cont 40#;-	L _ ITjavascriptcallconv -> cont 41#;-	L _ ITproc -> cont 42#;-	L _ ITrec -> cont 43#;-	L _ ITgroup -> cont 44#;-	L _ ITby -> cont 45#;-	L _ ITusing -> cont 46#;-	L _ ITpattern -> cont 47#;-	L _ ITstatic -> cont 48#;-	L _ ITstock -> cont 49#;-	L _ ITanyclass -> cont 50#;-	L _ ITvia -> cont 51#;-	L _ ITunit -> cont 52#;-	L _ ITsignature -> cont 53#;-	L _ ITdependency -> cont 54#;-	L _ (ITinline_prag _ _ _) -> cont 55#;-	L _ (ITspec_prag _) -> cont 56#;-	L _ (ITspec_inline_prag _ _) -> cont 57#;-	L _ (ITsource_prag _) -> cont 58#;-	L _ (ITrules_prag _) -> cont 59#;-	L _ (ITcore_prag _) -> cont 60#;-	L _ (ITscc_prag _) -> cont 61#;-	L _ (ITgenerated_prag _) -> cont 62#;-	L _ (ITdeprecated_prag _) -> cont 63#;-	L _ (ITwarning_prag _) -> cont 64#;-	L _ (ITunpack_prag _) -> cont 65#;-	L _ (ITnounpack_prag _) -> cont 66#;-	L _ (ITann_prag _) -> cont 67#;-	L _ (ITminimal_prag _) -> cont 68#;-	L _ (ITctype _) -> cont 69#;-	L _ (IToverlapping_prag _) -> cont 70#;-	L _ (IToverlappable_prag _) -> cont 71#;-	L _ (IToverlaps_prag _) -> cont 72#;-	L _ (ITincoherent_prag _) -> cont 73#;-	L _ (ITcomplete_prag _) -> cont 74#;-	L _ ITclose_prag -> cont 75#;-	L _ ITdotdot -> cont 76#;-	L _ ITcolon -> cont 77#;-	L _ (ITdcolon _) -> cont 78#;-	L _ ITequal -> cont 79#;-	L _ ITlam -> cont 80#;-	L _ ITlcase -> cont 81#;-	L _ ITvbar -> cont 82#;-	L _ (ITlarrow _) -> cont 83#;-	L _ (ITrarrow _) -> cont 84#;-	L _ ITat -> cont 85#;-	L _ (ITdarrow _) -> cont 86#;-	L _ ITminus -> cont 87#;-	L _ ITtilde -> cont 88#;-	L _ ITbang -> cont 89#;-	L _ (ITstar _) -> cont 90#;-	L _ (ITlarrowtail _) -> cont 91#;-	L _ (ITrarrowtail _) -> cont 92#;-	L _ (ITLarrowtail _) -> cont 93#;-	L _ (ITRarrowtail _) -> cont 94#;-	L _ ITdot -> cont 95#;-	L _ ITtypeApp -> cont 96#;-	L _ ITocurly -> cont 97#;-	L _ ITccurly -> cont 98#;-	L _ ITvocurly -> cont 99#;-	L _ ITvccurly -> cont 100#;-	L _ ITobrack -> cont 101#;-	L _ ITcbrack -> cont 102#;-	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 149# tk = happyError' (tk, explist)-happyError_ explist _ tk = happyError' (tk, explist)--happyThen :: () => P a -> (a -> P b) -> P b-happyThen = (>>=)-happyReturn :: () => a -> P a-happyReturn = (return)-happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn )--happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )--happyDoAction :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )--happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn ))--happyThen1 :: () => P a -> (a -> P b) -> P b-happyThen1 = happyThen-happyReturn1 :: () => a -> P a-happyReturn1 = happyReturn-happyError' :: () => (((Located Token)), [String]) -> P a-happyError' tk = (\(tokens, explist) -> happyError) tk-parseModule = happySomeParser where- happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {(HappyWrap34 x') = happyOut34 x} in x'))--parseSignature = happySomeParser where- happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (let {(HappyWrap33 x') = happyOut33 x} in x'))--parseImport = happySomeParser where- happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (let {(HappyWrap64 x') = happyOut64 x} in x'))--parseStatement = happySomeParser where- happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (let {(HappyWrap255 x') = happyOut255 x} in x'))--parseDeclaration = happySomeParser where- happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (let {(HappyWrap77 x') = happyOut77 x} in x'))--parseExpression = happySomeParser where- happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (let {(HappyWrap210 x') = happyOut210 x} in x'))--parsePattern = happySomeParser where- happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (let {(HappyWrap248 x') = happyOut248 x} in x'))--parseTypeSignature = happySomeParser where- happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (let {(HappyWrap206 x') = happyOut206 x} in x'))--parseStmt = happySomeParser where- happySomeParser = happyThen (happyParse 8#) (\x -> happyReturn (let {(HappyWrap254 x') = happyOut254 x} in x'))--parseIdentifier = happySomeParser where- happySomeParser = happyThen (happyParse 9#) (\x -> happyReturn (let {(HappyWrap16 x') = happyOut16 x} in x'))--parseType = happySomeParser where- happySomeParser = happyThen (happyParse 10#) (\x -> happyReturn (let {(HappyWrap156 x') = happyOut156 x} in x'))--parseBackpack = happySomeParser where- happySomeParser = happyThen (happyParse 11#) (\x -> happyReturn (let {(HappyWrap17 x') = happyOut17 x} in x'))--parseHeader = happySomeParser where- happySomeParser = happyThen (happyParse 12#) (\x -> happyReturn (let {(HappyWrap43 x') = happyOut43 x} in x'))--happySeq = happyDoSeq---happyError :: P a-happyError = srcParseFail--getVARID        (L _ (ITvarid    x)) = x-getCONID        (L _ (ITconid    x)) = x-getVARSYM       (L _ (ITvarsym   x)) = x-getCONSYM       (L _ (ITconsym   x)) = x-getQVARID       (L _ (ITqvarid   x)) = x-getQCONID       (L _ (ITqconid   x)) = x-getQVARSYM      (L _ (ITqvarsym  x)) = x-getQCONSYM      (L _ (ITqconsym  x)) = x-getIPDUPVARID   (L _ (ITdupipvarid   x)) = x-getLABELVARID   (L _ (ITlabelvarid   x)) = x-getCHAR         (L _ (ITchar   _ x)) = x-getSTRING       (L _ (ITstring _ x)) = x-getINTEGER      (L _ (ITinteger x))  = x-getRATIONAL     (L _ (ITrational x)) = x-getPRIMCHAR     (L _ (ITprimchar _ x)) = x-getPRIMSTRING   (L _ (ITprimstring _ x)) = x-getPRIMINTEGER  (L _ (ITprimint  _ x)) = x-getPRIMWORD     (L _ (ITprimword _ x)) = x-getPRIMFLOAT    (L _ (ITprimfloat x)) = x-getPRIMDOUBLE   (L _ (ITprimdouble x)) = x-getINLINE       (L _ (ITinline_prag _ inl conl)) = (inl,conl)-getSPEC_INLINE  (L _ (ITspec_inline_prag _ True))  = (Inline,  FunLike)-getSPEC_INLINE  (L _ (ITspec_inline_prag _ False)) = (NoInline,FunLike)-getCOMPLETE_PRAGs (L _ (ITcomplete_prag x)) = x--getDOCNEXT (L _ (ITdocCommentNext x)) = x-getDOCPREV (L _ (ITdocCommentPrev x)) = x-getDOCNAMED (L _ (ITdocCommentNamed x)) = x-getDOCSECTION (L _ (ITdocSection n x)) = (n, x)--getINTEGERs     (L _ (ITinteger (IL src _ _))) = src-getCHARs        (L _ (ITchar       src _)) = src-getSTRINGs      (L _ (ITstring     src _)) = src-getPRIMCHARs    (L _ (ITprimchar   src _)) = src-getPRIMSTRINGs  (L _ (ITprimstring src _)) = src-getPRIMINTEGERs (L _ (ITprimint    src _)) = src-getPRIMWORDs    (L _ (ITprimword   src _)) = src---- See Note [Pragma source text] in BasicTypes for the following-getINLINE_PRAGs       (L _ (ITinline_prag       src _ _)) = src-getSPEC_PRAGs         (L _ (ITspec_prag         src))     = src-getSPEC_INLINE_PRAGs  (L _ (ITspec_inline_prag  src _))   = src-getSOURCE_PRAGs       (L _ (ITsource_prag       src)) = src-getRULES_PRAGs        (L _ (ITrules_prag        src)) = src-getWARNING_PRAGs      (L _ (ITwarning_prag      src)) = src-getDEPRECATED_PRAGs   (L _ (ITdeprecated_prag   src)) = src-getSCC_PRAGs          (L _ (ITscc_prag          src)) = src-getGENERATED_PRAGs    (L _ (ITgenerated_prag    src)) = src-getCORE_PRAGs         (L _ (ITcore_prag         src)) = src-getUNPACK_PRAGs       (L _ (ITunpack_prag       src)) = src-getNOUNPACK_PRAGs     (L _ (ITnounpack_prag     src)) = src-getANN_PRAGs          (L _ (ITann_prag          src)) = src-getMINIMAL_PRAGs      (L _ (ITminimal_prag      src)) = src-getOVERLAPPABLE_PRAGs (L _ (IToverlappable_prag src)) = src-getOVERLAPPING_PRAGs  (L _ (IToverlapping_prag  src)) = src-getOVERLAPS_PRAGs     (L _ (IToverlaps_prag     src)) = src-getINCOHERENT_PRAGs   (L _ (ITincoherent_prag   src)) = src-getCTYPEs             (L _ (ITctype             src)) = src--getStringLiteral l = StringLiteral (getSTRINGs l) (getSTRING l)--isUnicode :: Located Token -> Bool-isUnicode (L _ (ITforall         iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITdarrow         iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITdcolon         iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITlarrow         iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITrarrow         iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITlarrowtail     iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITrarrowtail     iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITLarrowtail     iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITRarrowtail     iu)) = iu == UnicodeSyntax-isUnicode (L _ (IToparenbar      iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITcparenbar      iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITopenExpQuote _ iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITcloseQuote     iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITstar           iu)) = iu == UnicodeSyntax-isUnicode _                           = False--hasE :: Located Token -> Bool-hasE (L _ (ITopenExpQuote HasE _)) = True-hasE (L _ (ITopenTExpQuote HasE))  = True-hasE _                             = False--getSCC :: Located Token -> P FastString-getSCC lt = do let s = getSTRING lt-                   err = "Spaces are not allowed in SCCs"-               -- We probably actually want to be more restrictive than this-               if ' ' `elem` unpackFS s-                   then addFatalError (getLoc lt) (text err)-                   else return s---- Utilities for combining source spans-comb2 :: Located a -> Located b -> SrcSpan-comb2 a b = a `seq` b `seq` combineLocs a b--comb3 :: Located a -> Located b -> Located c -> SrcSpan-comb3 a b c = a `seq` b `seq` c `seq`-    combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))--comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan-comb4 a b c d = a `seq` b `seq` c `seq` d `seq`-    (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $-                combineSrcSpans (getLoc c) (getLoc d))---- strict constructor version:-{-# INLINE sL #-}-sL :: SrcSpan -> a -> Located a-sL span a = span `seq` a `seq` L span a---- See Note [Adding location info] for how these utility functions are used---- replaced last 3 CPP macros in this file-{-# INLINE sL0 #-}-sL0 :: a -> Located a-sL0 = L noSrcSpan       -- #define L0   L noSrcSpan--{-# INLINE sL1 #-}-sL1 :: Located a -> b -> Located b-sL1 x = sL (getLoc x)   -- #define sL1   sL (getLoc $1)--{-# INLINE sLL #-}-sLL :: Located a -> Located b -> c -> Located c-sLL x y = sL (comb2 x y) -- #define LL   sL (comb2 $1 $>)--{- Note [Adding location info]-   ~~~~~~~~~~~~~~~~~~~~~~~~~~~--This is done using the three functions below, sL0, sL1-and sLL.  Note that these functions were mechanically-converted from the three macros that used to exist before,-namely L0, L1 and LL.--They each add a SrcSpan to their argument.--   sL0  adds 'noSrcSpan', used for empty productions-     -- This doesn't seem to work anymore -=chak--   sL1  for a production with a single token on the lhs.  Grabs the SrcSpan-        from that token.--   sLL  for a production with >1 token on the lhs.  Makes up a SrcSpan from-        the first and last tokens.--These suffice for the majority of cases.  However, we must be-especially careful with empty productions: sLL won't work if the first-or last token on the lhs can represent an empty span.  In these cases,-we have to calculate the span using more of the tokens from the lhs, eg.--        | 'newtype' tycl_hdr '=' newconstr deriving-                { L (comb3 $1 $4 $5)-                    (mkTyData NewType (unLoc $2) $4 (unLoc $5)) }--We provide comb3 and comb4 functions which are useful in such cases.--Be careful: there's no checking that you actually got this right, the-only symptom will be that the SrcSpans of your syntax will be-incorrect.---}---- Make a source location for the file.  We're a bit lazy here and just--- make a point SrcSpan at line 1, column 0.  Strictly speaking we should--- try to find the span of the whole file (ToDo).-fileSrcSpan :: P SrcSpan-fileSrcSpan = do-  l <- getRealSrcLoc;-  let loc = mkSrcLoc (srcLocFile l) 1 1;-  return (mkSrcSpan loc loc)---- Hint about the MultiWayIf extension-hintMultiWayIf :: SrcSpan -> P ()-hintMultiWayIf span = do-  mwiEnabled <- getBit MultiWayIfBit-  unless mwiEnabled $ addError span $-    text "Multi-way if-expressions need MultiWayIf turned on"---- Hint about explicit-forall-hintExplicitForall :: Located Token -> P ()-hintExplicitForall tok = do-    forall   <- getBit ExplicitForallBit-    rulePrag <- getBit InRulePragBit-    unless (forall || rulePrag) $ addError (getLoc tok) $ vcat-      [ text "Illegal symbol" <+> quotes forallSymDoc <+> text "in type"-      , text "Perhaps you intended to use RankNTypes or a similar language"-      , text "extension to enable explicit-forall syntax:" <+>-        forallSymDoc <+> text "<tvs>. <type>"-      ]-  where-    forallSymDoc = text (forallSym (isUnicode tok))---- When two single quotes don't followed by tyvar or gtycon, we report the--- error as empty character literal, or TH quote that missing proper type--- variable or constructor. See #13450.-reportEmptyDoubleQuotes :: SrcSpan -> P a-reportEmptyDoubleQuotes span = do-    thQuotes <- getBit ThQuotesBit-    if thQuotes-      then addFatalError span $ vcat-        [ text "Parser error on `''`"-        , text "Character literals may not be empty"-        , text "Or perhaps you intended to use quotation syntax of TemplateHaskell,"-        , text "but the type variable or constructor is missing"-        ]-      else addFatalError span $ vcat-        [ text "Parser error on `''`"-        , text "Character literals may not be empty"-        ]--{--%************************************************************************-%*                                                                      *-        Helper functions for generating annotations in the parser-%*                                                                      *-%************************************************************************--For the general principles of the following routines, see Note [Api annotations]-in ApiAnnotation.hs---}---- |Construct an AddAnn from the annotation keyword and the location--- of the keyword itself-mj :: AnnKeywordId -> Located e -> AddAnn-mj a l = AddAnn a (gl l)----- |Construct an AddAnn from the annotation keyword and the Located Token. If--- the token has a unicode equivalent and this has been used, provide the--- unicode variant of the annotation.-mu :: AnnKeywordId -> Located Token -> AddAnn-mu a lt@(L l t) = AddAnn (toUnicodeAnn a lt) l---- | If the 'Token' is using its unicode variant return the unicode variant of---   the annotation-toUnicodeAnn :: AnnKeywordId -> Located Token -> AnnKeywordId-toUnicodeAnn a t = if isUnicode t then unicodeAnn a else a--gl :: Located a -> SrcSpan-gl = getLoc---- |Add an annotation to the located element, and return the located--- element as a pass through-aa :: Located a -> (AnnKeywordId, Located c) -> P (Located a)-aa a@(L l _) (b,s) = addAnnotation l b (gl s) >> return a---- |Add an annotation to a located element resulting from a monadic action-am :: P (Located a) -> (AnnKeywordId, Located b) -> P (Located a)-am a (b,s) = do-  av@(L l _) <- a-  addAnnotation l b (gl s)-  return av---- | Add a list of AddAnns to the given AST element.  For example,--- the parsing rule for @let@ looks like:------ @---      | 'let' binds 'in' exp    {% ams (sLL $1 $> $ HsLet (snd $ unLoc $2) $4)---                                       (mj AnnLet $1:mj AnnIn $3---                                         :(fst $ unLoc $2)) }--- @------ This adds an AnnLet annotation for @let@, an AnnIn for @in@, as well--- as any annotations that may arise in the binds. This will include open--- and closing braces if they are used to delimit the let expressions.----ams :: MonadP m => Located a -> [AddAnn] -> m (Located a)-ams a@(L l _) bs = addAnnsAt l bs >> return a--amsL :: SrcSpan -> [AddAnn] -> P ()-amsL sp bs = addAnnsAt sp bs >> return ()---- |Add all [AddAnn] to an AST element, and wrap it in a 'Just'-ajs :: MonadP m => Located a -> [AddAnn] -> m (Maybe (Located a))-ajs a bs = Just <$> ams a bs---- |Add a list of AddAnns to the given AST element, where the AST element is the---  result of a monadic action-amms :: MonadP m => m (Located a) -> [AddAnn] -> m (Located a)-amms a bs = do { av@(L l _) <- a-               ; addAnnsAt l bs-               ; return av }---- |Add a list of AddAnns to the AST element, and return the element as a---  OrdList-amsu :: Located a -> [AddAnn] -> P (OrdList (Located a))-amsu a@(L l _) bs = addAnnsAt l bs >> return (unitOL a)---- |Synonyms for AddAnn versions of AnnOpen and AnnClose-mo,mc :: Located Token -> AddAnn-mo ll = mj AnnOpen ll-mc ll = mj AnnClose ll--moc,mcc :: Located Token -> AddAnn-moc ll = mj AnnOpenC ll-mcc ll = mj AnnCloseC ll--mop,mcp :: Located Token -> AddAnn-mop ll = mj AnnOpenP ll-mcp ll = mj AnnCloseP ll--mos,mcs :: Located Token -> AddAnn-mos ll = mj AnnOpenS ll-mcs ll = mj AnnCloseS ll---- |Given a list of the locations of commas, provide a [AddAnn] with an AnnComma---  entry for each SrcSpan-mcommas :: [SrcSpan] -> [AddAnn]-mcommas = map (AddAnn AnnCommaTuple)---- |Given a list of the locations of '|'s, provide a [AddAnn] with an AnnVbar---  entry for each SrcSpan-mvbars :: [SrcSpan] -> [AddAnn]-mvbars = map (AddAnn AnnVbar)---- |Get the location of the last element of a OrdList, or noSrcSpan-oll :: OrdList (Located a) -> SrcSpan-oll l =-  if isNilOL l then noSrcSpan-               else getLoc (lastOL l)---- |Add a semicolon annotation in the right place in a list. If the--- leading list is empty, add it to the tail-asl :: [Located a] -> Located b -> Located a -> P ()-asl [] (L ls _) (L l _) = addAnnotation l          AnnSemi ls-asl (x:_xs) (L ls _) _x = addAnnotation (getLoc x) AnnSemi ls-{-# LINE 1 "templates/GenericTemplate.hs" #-}--- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $---------------- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.-#if __GLASGOW_HASKELL__ > 706-#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool)-#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool)-#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool)-#else-#define LT(n,m) (n Happy_GHC_Exts.<# m)-#define GTE(n,m) (n Happy_GHC_Exts.>=# m)-#define EQ(n,m) (n Happy_GHC_Exts.==# m)-#endif--------------------data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList-----------------------------------------infixr 9 `HappyStk`-data HappyStk a = HappyStk a (HappyStk a)---------------------------------------------------------------------------------- starting the parse--happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll---------------------------------------------------------------------------------- Accepting the parse---- If the current token is ERROR_TOK, it means we've just accepted a partial--- parse (a %partial parser).  We must ignore the saved token on the top of--- the stack in this case.-happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =-        happyReturn1 ans-happyAccept j tk st sts (HappyStk ans _) = -        (happyTcHack j (happyTcHack st)) (happyReturn1 ans)---------------------------------------------------------------------------------- Arrays only: do the next action----happyDoAction i tk st-        = {- nothing -}-          case action of-                0#           -> {- nothing -}-                                     happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Int)) i tk st-                -1#          -> {- nothing -}-                                     happyAccept i tk st-                n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}-                                                   (happyReduceArr Happy_Data_Array.! rule) i tk st-                                                   where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))-                n                 -> {- nothing -}-                                     happyShift new_state i tk st-                                     where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))-   where off    = happyAdjustOffset (indexShortOffAddr happyActOffsets st)-         off_i  = (off Happy_GHC_Exts.+# i)-         check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))-                  then EQ(indexShortOffAddr happyCheck off_i, i)-                  else False-         action-          | check     = indexShortOffAddr happyTable off_i-          | otherwise = indexShortOffAddr happyDefActions st-----indexShortOffAddr (HappyA# arr) off =-        Happy_GHC_Exts.narrow16Int# i-  where-        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)-        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))-        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))-        off' = off Happy_GHC_Exts.*# 2#-----{-# INLINE happyLt #-}-happyLt x y = LT(x,y)---readArrayBit arr bit =-    Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `mod` 16)-  where unbox_int (Happy_GHC_Exts.I# x) = x-------data HappyAddr = HappyA# Happy_GHC_Exts.Addr#----------------------------------------------------------------------------------- HappyState data type (not arrays)---------------------------------------------------------------------------------------------- Shifting a token--happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =-     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in---     trace "shifting the error token" $-     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)--happyShift new_state i tk st sts stk =-     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)---- happyReduce is specialised for the common cases.--happySpecReduce_0 i fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happySpecReduce_0 nt fn j tk st@((action)) sts stk-     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)--happySpecReduce_1 i fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')-     = let r = fn v1 in-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_2 i fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')-     = let r = fn v1 v2 in-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_3 i fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')-     = let r = fn v1 v2 v3 in-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happyReduce k i fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happyReduce k nt fn j tk st sts stk-     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of-         sts1@((HappyCons (st1@(action)) (_))) ->-                let r = fn stk in  -- it doesn't hurt to always seq here...-                happyDoSeq r (happyGoto nt j tk st1 sts1 r)--happyMonadReduce k nt fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happyMonadReduce k nt fn j tk st sts stk =-      case happyDrop k (HappyCons (st) (sts)) of-        sts1@((HappyCons (st1@(action)) (_))) ->-          let drop_stk = happyDropStk k stk in-          happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))--happyMonad2Reduce k nt fn 0# tk st sts stk-     = happyFail [] 0# tk st sts stk-happyMonad2Reduce k nt fn j tk st sts stk =-      case happyDrop k (HappyCons (st) (sts)) of-        sts1@((HappyCons (st1@(action)) (_))) ->-         let drop_stk = happyDropStk k stk--             off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1)-             off_i = (off Happy_GHC_Exts.+# nt)-             new_state = indexShortOffAddr happyTable off_i-----          in-          happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))--happyDrop 0# l = l-happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t--happyDropStk 0# l = l-happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs---------------------------------------------------------------------------------- Moving to a new state after a reduction---happyGoto nt j tk st = -   {- nothing -}-   happyDoAction j tk new_state-   where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st)-         off_i = (off Happy_GHC_Exts.+# nt)-         new_state = indexShortOffAddr happyTable off_i------------------------------------------------------------------------------------- Error recovery (ERROR_TOK is the error token)---- parse error if we are in recovery and we fail again-happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) =-     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in---      trace "failing" $ -        happyError_ explist i tk--{-  We don't need state discarding for our restricted implementation of-    "error".  In fact, it can cause some bogus parses, so I've disabled it-    for now --SDM---- discard a state-happyFail  ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) -                                                (saved_tok `HappyStk` _ `HappyStk` stk) =---      trace ("discarding state, depth " ++ show (length stk))  $-        DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk))--}---- Enter error recovery: generate an error token,---                       save the old token and carry on.-happyFail explist i tk (action) sts stk =---      trace "entering error recovery" $-        happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)---- Internal happy errors:--notHappyAtAll :: a-notHappyAtAll = error "Internal Happy error\n"---------------------------------------------------------------------------------- Hack to get the typechecker to accept our action functions---happyTcHack :: Happy_GHC_Exts.Int# -> a -> a-happyTcHack x y = y-{-# INLINE happyTcHack #-}----------------------------------------------------------------------------------- Seq-ing.  If the --strict flag is given, then Happy emits ---      happySeq = happyDoSeq--- otherwise it emits---      happySeq = happyDontSeq--happyDoSeq, happyDontSeq :: a -> b -> b-happyDoSeq   a b = a `seq` b-happyDontSeq a b = b---------------------------------------------------------------------------------- Don't inline any functions from the template.  GHC has a nasty habit--- of deciding to inline happyGoto everywhere, which increases the size of--- the generated parser quite a bit.---{-# NOINLINE happyDoAction #-}-{-# NOINLINE happyTable #-}-{-# NOINLINE happyCheck #-}-{-# NOINLINE happyActOffsets #-}-{-# NOINLINE happyGotoOffsets #-}-{-# NOINLINE happyDefActions #-}--{-# NOINLINE happyShift #-}-{-# NOINLINE happySpecReduce_0 #-}-{-# NOINLINE happySpecReduce_1 #-}-{-# NOINLINE happySpecReduce_2 #-}-{-# NOINLINE happySpecReduce_3 #-}-{-# NOINLINE happyReduce #-}-{-# NOINLINE happyMonadReduce #-}-{-# NOINLINE happyGoto #-}-{-# NOINLINE happyFail #-}---- end of Happy Template.
+ ghc-lib/stage0/compiler/build/primop-docs.hs-incl view
@@ -0,0 +1,875 @@+primOpDocs =+  [ ("->","The builtin function type, written in infix form as @a -> b@ and\n   in prefix form as @(->) a b@. Values of this type are functions\n   taking inputs of type @a@ and producing outputs of type @b@.\n\n   Note that @a -> b@ permits levity-polymorphism in both @a@ and\n   @b@, so that types like @Int\\# -> Int\\#@ can still be well-kinded.\n  ")+  , ("*#","Low word of signed integer multiply.")+  , ("timesInt2#","Return a triple (isHighNeeded,high,low) where high and low are respectively\n   the high and low bits of the double-word result. isHighNeeded is a cheap way\n   to test if the high word is a sign-extension of the low word (isHighNeeded =\n   0#) or not (isHighNeeded = 1#).")+  , ("mulIntMayOflo#","Return non-zero if there is any possibility that the upper word of a\n    signed integer multiply might contain useful information.  Return\n    zero only if you are completely sure that no overflow can occur.\n    On a 32-bit platform, the recommended implementation is to do a\n    32 x 32 -> 64 signed multiply, and subtract result[63:32] from\n    (result[31] >>signed 31).  If this is zero, meaning that the\n    upper word is merely a sign extension of the lower one, no\n    overflow can occur.\n\n    On a 64-bit platform it is not always possible to\n    acquire the top 64 bits of the result.  Therefore, a recommended\n    implementation is to take the absolute value of both operands, and\n    return 0 iff bits[63:31] of them are zero, since that means that their\n    magnitudes fit within 31 bits, so the magnitude of the product must fit\n    into 62 bits.\n\n    If in doubt, return non-zero, but do make an effort to create the\n    correct answer for small args, since otherwise the performance of\n    @(*) :: Integer -> Integer -> Integer@ will be poor.\n   ")+  , ("quotInt#","Rounds towards zero. The behavior is undefined if the second argument is\n    zero.\n   ")+  , ("remInt#","Satisfies @(quotInt\\# x y) *\\# y +\\# (remInt\\# x y) == x@. The\n    behavior is undefined if the second argument is zero.\n   ")+  , ("quotRemInt#","Rounds towards zero.")+  , ("andI#","Bitwise \"and\".")+  , ("orI#","Bitwise \"or\".")+  , ("xorI#","Bitwise \"xor\".")+  , ("notI#","Bitwise \"not\", also known as the binary complement.")+  , ("negateInt#","Unary negation.\n    Since the negative @Int#@ range extends one further than the\n    positive range, @negateInt#@ of the most negative number is an\n    identity operation. This way, @negateInt#@ is always its own inverse.")+  , ("addIntC#","Add signed integers reporting overflow.\n          First member of result is the sum truncated to an @Int#@;\n          second member is zero if the true sum fits in an @Int#@,\n          nonzero if overflow occurred (the sum is either too large\n          or too small to fit in an @Int#@).")+  , ("subIntC#","Subtract signed integers reporting overflow.\n          First member of result is the difference truncated to an @Int#@;\n          second member is zero if the true difference fits in an @Int#@,\n          nonzero if overflow occurred (the difference is either too large\n          or too small to fit in an @Int#@).")+  , ("uncheckedIShiftL#","Shift left.  Result undefined if shift amount is not\n          in the range 0 to word size - 1 inclusive.")+  , ("uncheckedIShiftRA#","Shift right arithmetic.  Result undefined if shift amount is not\n          in the range 0 to word size - 1 inclusive.")+  , ("uncheckedIShiftRL#","Shift right logical.  Result undefined if shift amount is not\n          in the range 0 to word size - 1 inclusive.")+  , ("addWordC#","Add unsigned integers reporting overflow.\n          The first element of the pair is the result.  The second element is\n          the carry flag, which is nonzero on overflow. See also @plusWord2#@.")+  , ("subWordC#","Subtract unsigned integers reporting overflow.\n          The first element of the pair is the result.  The second element is\n          the carry flag, which is nonzero on overflow.")+  , ("plusWord2#","Add unsigned integers, with the high part (carry) in the first\n          component of the returned pair and the low part in the second\n          component of the pair. See also @addWordC#@.")+  , ("quotRemWord2#"," Takes high word of dividend, then low word of dividend, then divisor.\n           Requires that high word < divisor.")+  , ("uncheckedShiftL#","Shift left logical.   Result undefined if shift amount is not\n          in the range 0 to word size - 1 inclusive.")+  , ("uncheckedShiftRL#","Shift right logical.   Result undefined if shift  amount is not\n          in the range 0 to word size - 1 inclusive.")+  , ("popCnt8#","Count the number of set bits in the lower 8 bits of a word.")+  , ("popCnt16#","Count the number of set bits in the lower 16 bits of a word.")+  , ("popCnt32#","Count the number of set bits in the lower 32 bits of a word.")+  , ("popCnt64#","Count the number of set bits in a 64-bit word.")+  , ("popCnt#","Count the number of set bits in a word.")+  , ("pdep8#","Deposit bits to lower 8 bits of a word at locations specified by a mask.")+  , ("pdep16#","Deposit bits to lower 16 bits of a word at locations specified by a mask.")+  , ("pdep32#","Deposit bits to lower 32 bits of a word at locations specified by a mask.")+  , ("pdep64#","Deposit bits to a word at locations specified by a mask.")+  , ("pdep#","Deposit bits to a word at locations specified by a mask.")+  , ("pext8#","Extract bits from lower 8 bits of a word at locations specified by a mask.")+  , ("pext16#","Extract bits from lower 16 bits of a word at locations specified by a mask.")+  , ("pext32#","Extract bits from lower 32 bits of a word at locations specified by a mask.")+  , ("pext64#","Extract bits from a word at locations specified by a mask.")+  , ("pext#","Extract bits from a word at locations specified by a mask.")+  , ("clz8#","Count leading zeros in the lower 8 bits of a word.")+  , ("clz16#","Count leading zeros in the lower 16 bits of a word.")+  , ("clz32#","Count leading zeros in the lower 32 bits of a word.")+  , ("clz64#","Count leading zeros in a 64-bit word.")+  , ("clz#","Count leading zeros in a word.")+  , ("ctz8#","Count trailing zeros in the lower 8 bits of a word.")+  , ("ctz16#","Count trailing zeros in the lower 16 bits of a word.")+  , ("ctz32#","Count trailing zeros in the lower 32 bits of a word.")+  , ("ctz64#","Count trailing zeros in a 64-bit word.")+  , ("ctz#","Count trailing zeros in a word.")+  , ("byteSwap16#","Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. ")+  , ("byteSwap32#","Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. ")+  , ("byteSwap64#","Swap bytes in a 64 bits of a word.")+  , ("byteSwap#","Swap bytes in a word.")+  , ("bitReverse8#","Reverse the order of the bits in a 8-bit word.")+  , ("bitReverse16#","Reverse the order of the bits in a 16-bit word.")+  , ("bitReverse32#","Reverse the order of the bits in a 32-bit word.")+  , ("bitReverse64#","Reverse the order of the bits in a 64-bit word.")+  , ("bitReverse#","Reverse the order of the bits in a word.")+  , ("double2Int#","Truncates a @Double#@ value to the nearest @Int#@.\n    Results are undefined if the truncation if truncation yields\n    a value outside the range of @Int#@.")+  , ("**##","Exponentiation.")+  , ("decodeDouble_2Int#","Convert to integer.\n    First component of the result is -1 or 1, indicating the sign of the\n    mantissa. The next two are the high and low 32 bits of the mantissa\n    respectively, and the last is the exponent.")+  , ("decodeDouble_Int64#","Decode @Double\\#@ into mantissa and base-2 exponent.")+  , ("float2Int#","Truncates a @Float#@ value to the nearest @Int#@.\n    Results are undefined if the truncation if truncation yields\n    a value outside the range of @Int#@.")+  , ("decodeFloat_Int#","Convert to integers.\n    First @Int\\#@ in result is the mantissa; second is the exponent.")+  , ("newArray#","Create a new mutable array with the specified number of elements,\n    in the specified state thread,\n    with each element containing the specified initial value.")+  , ("readArray#","Read from specified index of mutable array. Result is not yet evaluated.")+  , ("writeArray#","Write to specified index of mutable array.")+  , ("sizeofArray#","Return the number of elements in the array.")+  , ("sizeofMutableArray#","Return the number of elements in the array.")+  , ("indexArray#","Read from the specified index of an immutable array. The result is packaged\n    into an unboxed unary tuple; the result itself is not yet\n    evaluated. Pattern matching on the tuple forces the indexing of the\n    array to happen but does not evaluate the element itself. Evaluating\n    the thunk prevents additional thunks from building up on the\n    heap. Avoiding these thunks, in turn, reduces references to the\n    argument array, allowing it to be garbage collected more promptly.")+  , ("unsafeFreezeArray#","Make a mutable array immutable, without copying.")+  , ("unsafeThawArray#","Make an immutable array mutable, without copying.")+  , ("copyArray#","Given a source array, an offset into the source array, a\n   destination array, an offset into the destination array, and a\n   number of elements to copy, copy the elements from the source array\n   to the destination array. Both arrays must fully contain the\n   specified ranges, but this is not checked. The two arrays must not\n   be the same array in different states, but this is not checked\n   either.")+  , ("copyMutableArray#","Given a source array, an offset into the source array, a\n   destination array, an offset into the destination array, and a\n   number of elements to copy, copy the elements from the source array\n   to the destination array. Both arrays must fully contain the\n   specified ranges, but this is not checked. In the case where\n   the source and destination are the same array the source and\n   destination regions may overlap.")+  , ("cloneArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("cloneMutableArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("freezeArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("thawArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("casArray#","Given an array, an offset, the expected old value, and\n    the new value, perform an atomic compare and swap (i.e. write the new\n    value if the current value and the old value are the same pointer).\n    Returns 0 if the swap succeeds and 1 if it fails. Additionally, returns\n    the element at the offset after the operation completes. This means that\n    on a success the new value is returned, and on a failure the actual old\n    value (not the expected one) is returned. Implies a full memory barrier.\n    The use of a pointer equality on a lifted value makes this function harder\n    to use correctly than @casIntArray\\#@. All of the difficulties\n    of using @reallyUnsafePtrEquality\\#@ correctly apply to\n    @casArray\\#@ as well.\n   ")+  , ("newSmallArray#","Create a new mutable array with the specified number of elements,\n    in the specified state thread,\n    with each element containing the specified initial value.")+  , ("shrinkSmallMutableArray#","Shrink mutable array to new specified size, in\n    the specified state thread. The new size argument must be less than or\n    equal to the current size as reported by @sizeofSmallMutableArray\\#@.")+  , ("readSmallArray#","Read from specified index of mutable array. Result is not yet evaluated.")+  , ("writeSmallArray#","Write to specified index of mutable array.")+  , ("sizeofSmallArray#","Return the number of elements in the array.")+  , ("sizeofSmallMutableArray#","Return the number of elements in the array. Note that this is deprecated\n   as it is unsafe in the presence of resize operations on the\n   same byte array.")+  , ("getSizeofSmallMutableArray#","Return the number of elements in the array.")+  , ("indexSmallArray#","Read from specified index of immutable array. Result is packaged into\n    an unboxed singleton; the result itself is not yet evaluated.")+  , ("unsafeFreezeSmallArray#","Make a mutable array immutable, without copying.")+  , ("unsafeThawSmallArray#","Make an immutable array mutable, without copying.")+  , ("copySmallArray#","Given a source array, an offset into the source array, a\n   destination array, an offset into the destination array, and a\n   number of elements to copy, copy the elements from the source array\n   to the destination array. Both arrays must fully contain the\n   specified ranges, but this is not checked. The two arrays must not\n   be the same array in different states, but this is not checked\n   either.")+  , ("copySmallMutableArray#","Given a source array, an offset into the source array, a\n   destination array, an offset into the destination array, and a\n   number of elements to copy, copy the elements from the source array\n   to the destination array. The source and destination arrays can\n   refer to the same array. Both arrays must fully contain the\n   specified ranges, but this is not checked.\n   The regions are allowed to overlap, although this is only possible when the same\n   array is provided as both the source and the destination. ")+  , ("cloneSmallArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("cloneSmallMutableArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("freezeSmallArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("thawSmallArray#","Given a source array, an offset into the source array, and a number\n   of elements to copy, create a new array with the elements from the\n   source array. The provided array must fully contain the specified\n   range, but this is not checked.")+  , ("casSmallArray#","Unsafe, machine-level atomic compare and swap on an element within an array.\n    See the documentation of @casArray\\#@.")+  , ("newByteArray#","Create a new mutable byte array of specified size (in bytes), in\n    the specified state thread.")+  , ("newPinnedByteArray#","Create a mutable byte array that the GC guarantees not to move.")+  , ("newAlignedPinnedByteArray#","Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.")+  , ("isMutableByteArrayPinned#","Determine whether a @MutableByteArray\\#@ is guaranteed not to move\n   during GC.")+  , ("isByteArrayPinned#","Determine whether a @ByteArray\\#@ is guaranteed not to move during GC.")+  , ("byteArrayContents#","Intended for use with pinned arrays; otherwise very unsafe!")+  , ("shrinkMutableByteArray#","Shrink mutable byte array to new specified size (in bytes), in\n    the specified state thread. The new size argument must be less than or\n    equal to the current size as reported by @sizeofMutableByteArray\\#@.")+  , ("resizeMutableByteArray#","Resize (unpinned) mutable byte array to new specified size (in bytes).\n    The returned @MutableByteArray\\#@ is either the original\n    @MutableByteArray\\#@ resized in-place or, if not possible, a newly\n    allocated (unpinned) @MutableByteArray\\#@ (with the original content\n    copied over).\n\n    To avoid undefined behaviour, the original @MutableByteArray\\#@ shall\n    not be accessed anymore after a @resizeMutableByteArray\\#@ has been\n    performed.  Moreover, no reference to the old one should be kept in order\n    to allow garbage collection of the original @MutableByteArray\\#@ in\n    case a new @MutableByteArray\\#@ had to be allocated.")+  , ("unsafeFreezeByteArray#","Make a mutable byte array immutable, without copying.")+  , ("sizeofByteArray#","Return the size of the array in bytes.")+  , ("sizeofMutableByteArray#","Return the size of the array in bytes. Note that this is deprecated as it is\n   unsafe in the presence of resize operations on the same byte\n   array.")+  , ("getSizeofMutableByteArray#","Return the number of elements in the array.")+  , ("indexCharArray#","Read 8-bit character; offset in bytes.")+  , ("indexWideCharArray#","Read 31-bit character; offset in 4-byte words.")+  , ("indexInt8Array#","Read 8-bit integer; offset in bytes.")+  , ("indexInt16Array#","Read 16-bit integer; offset in 16-bit words.")+  , ("indexInt32Array#","Read 32-bit integer; offset in 32-bit words.")+  , ("indexInt64Array#","Read 64-bit integer; offset in 64-bit words.")+  , ("indexWord8Array#","Read 8-bit word; offset in bytes.")+  , ("indexWord16Array#","Read 16-bit word; offset in 16-bit words.")+  , ("indexWord32Array#","Read 32-bit word; offset in 32-bit words.")+  , ("indexWord64Array#","Read 64-bit word; offset in 64-bit words.")+  , ("indexWord8ArrayAsChar#","Read 8-bit character; offset in bytes.")+  , ("indexWord8ArrayAsWideChar#","Read 31-bit character; offset in bytes.")+  , ("indexWord8ArrayAsAddr#","Read address; offset in bytes.")+  , ("indexWord8ArrayAsFloat#","Read float; offset in bytes.")+  , ("indexWord8ArrayAsDouble#","Read double; offset in bytes.")+  , ("indexWord8ArrayAsStablePtr#","Read stable pointer; offset in bytes.")+  , ("indexWord8ArrayAsInt16#","Read 16-bit int; offset in bytes.")+  , ("indexWord8ArrayAsInt32#","Read 32-bit int; offset in bytes.")+  , ("indexWord8ArrayAsInt64#","Read 64-bit int; offset in bytes.")+  , ("indexWord8ArrayAsInt#","Read int; offset in bytes.")+  , ("indexWord8ArrayAsWord16#","Read 16-bit word; offset in bytes.")+  , ("indexWord8ArrayAsWord32#","Read 32-bit word; offset in bytes.")+  , ("indexWord8ArrayAsWord64#","Read 64-bit word; offset in bytes.")+  , ("indexWord8ArrayAsWord#","Read word; offset in bytes.")+  , ("readCharArray#","Read 8-bit character; offset in bytes.")+  , ("readWideCharArray#","Read 31-bit character; offset in 4-byte words.")+  , ("readIntArray#","Read integer; offset in machine words.")+  , ("readWordArray#","Read word; offset in machine words.")+  , ("writeCharArray#","Write 8-bit character; offset in bytes.")+  , ("writeWideCharArray#","Write 31-bit character; offset in 4-byte words.")+  , ("compareByteArrays#","@compareByteArrays# src1 src1_ofs src2 src2_ofs n@ compares\n    @n@ bytes starting at offset @src1_ofs@ in the first\n    @ByteArray#@ @src1@ to the range of @n@ bytes\n    (i.e. same length) starting at offset @src2_ofs@ of the second\n    @ByteArray#@ @src2@.  Both arrays must fully contain the\n    specified ranges, but this is not checked.  Returns an @Int#@\n    less than, equal to, or greater than zero if the range is found,\n    respectively, to be byte-wise lexicographically less than, to\n    match, or be greater than the second range.")+  , ("copyByteArray#","@copyByteArray# src src_ofs dst dst_ofs n@ copies the range\n   starting at offset @src_ofs@ of length @n@ from the\n   @ByteArray#@ @src@ to the @MutableByteArray#@ @dst@\n   starting at offset @dst_ofs@.  Both arrays must fully contain\n   the specified ranges, but this is not checked.  The two arrays must\n   not be the same array in different states, but this is not checked\n   either.")+  , ("copyMutableByteArray#","Copy a range of the first MutableByteArray\\# to the specified region in the second MutableByteArray\\#.\n   Both arrays must fully contain the specified ranges, but this is not checked. The regions are\n   allowed to overlap, although this is only possible when the same array is provided\n   as both the source and the destination.")+  , ("copyByteArrayToAddr#","Copy a range of the ByteArray\\# to the memory range starting at the Addr\\#.\n   The ByteArray\\# and the memory region at Addr\\# must fully contain the\n   specified ranges, but this is not checked. The Addr\\# must not point into the\n   ByteArray\\# (e.g. if the ByteArray\\# were pinned), but this is not checked\n   either.")+  , ("copyMutableByteArrayToAddr#","Copy a range of the MutableByteArray\\# to the memory range starting at the\n   Addr\\#. The MutableByteArray\\# and the memory region at Addr\\# must fully\n   contain the specified ranges, but this is not checked. The Addr\\# must not\n   point into the MutableByteArray\\# (e.g. if the MutableByteArray\\# were\n   pinned), but this is not checked either.")+  , ("copyAddrToByteArray#","Copy a memory range starting at the Addr\\# to the specified range in the\n   MutableByteArray\\#. The memory region at Addr\\# and the ByteArray\\# must fully\n   contain the specified ranges, but this is not checked. The Addr\\# must not\n   point into the MutableByteArray\\# (e.g. if the MutableByteArray\\# were pinned),\n   but this is not checked either.")+  , ("setByteArray#","@setByteArray# ba off len c@ sets the byte range @[off, off+len]@ of\n   the @MutableByteArray#@ to the byte @c@.")+  , ("atomicReadIntArray#","Given an array and an offset in machine words, read an element. The\n    index is assumed to be in bounds. Implies a full memory barrier.")+  , ("atomicWriteIntArray#","Given an array and an offset in machine words, write an element. The\n    index is assumed to be in bounds. Implies a full memory barrier.")+  , ("casIntArray#","Given an array, an offset in machine words, the expected old value, and\n    the new value, perform an atomic compare and swap i.e. write the new\n    value if the current value matches the provided old value. Returns\n    the value of the element before the operation. Implies a full memory\n    barrier.")+  , ("fetchAddIntArray#","Given an array, and offset in machine words, and a value to add,\n    atomically add the value to the element. Returns the value of the\n    element before the operation. Implies a full memory barrier.")+  , ("fetchSubIntArray#","Given an array, and offset in machine words, and a value to subtract,\n    atomically subtract the value to the element. Returns the value of\n    the element before the operation. Implies a full memory barrier.")+  , ("fetchAndIntArray#","Given an array, and offset in machine words, and a value to AND,\n    atomically AND the value to the element. Returns the value of the\n    element before the operation. Implies a full memory barrier.")+  , ("fetchNandIntArray#","Given an array, and offset in machine words, and a value to NAND,\n    atomically NAND the value to the element. Returns the value of the\n    element before the operation. Implies a full memory barrier.")+  , ("fetchOrIntArray#","Given an array, and offset in machine words, and a value to OR,\n    atomically OR the value to the element. Returns the value of the\n    element before the operation. Implies a full memory barrier.")+  , ("fetchXorIntArray#","Given an array, and offset in machine words, and a value to XOR,\n    atomically XOR the value to the element. Returns the value of the\n    element before the operation. Implies a full memory barrier.")+  , ("newArrayArray#","Create a new mutable array of arrays with the specified number of elements,\n    in the specified state thread, with each element recursively referring to the\n    newly created array.")+  , ("unsafeFreezeArrayArray#","Make a mutable array of arrays immutable, without copying.")+  , ("sizeofArrayArray#","Return the number of elements in the array.")+  , ("sizeofMutableArrayArray#","Return the number of elements in the array.")+  , ("copyArrayArray#","Copy a range of the ArrayArray\\# to the specified region in the MutableArrayArray\\#.\n   Both arrays must fully contain the specified ranges, but this is not checked.\n   The two arrays must not be the same array in different states, but this is not checked either.")+  , ("copyMutableArrayArray#","Copy a range of the first MutableArrayArray# to the specified region in the second\n   MutableArrayArray#.\n   Both arrays must fully contain the specified ranges, but this is not checked.\n   The regions are allowed to overlap, although this is only possible when the same\n   array is provided as both the source and the destination.\n   ")+  , ("Addr#"," An arbitrary machine address assumed to point outside\n         the garbage-collected heap. ")+  , ("nullAddr#"," The null address. ")+  , ("minusAddr#","Result is meaningless if two @Addr\\#@s are so far apart that their\n         difference doesn't fit in an @Int\\#@.")+  , ("remAddr#","Return the remainder when the @Addr\\#@ arg, treated like an @Int\\#@,\n          is divided by the @Int\\#@ arg.")+  , ("addr2Int#","Coerce directly from address to int.")+  , ("int2Addr#","Coerce directly from int to address.")+  , ("indexCharOffAddr#","Reads 8-bit character; offset in bytes.")+  , ("indexWideCharOffAddr#","Reads 31-bit character; offset in 4-byte words.")+  , ("readCharOffAddr#","Reads 8-bit character; offset in bytes.")+  , ("readWideCharOffAddr#","Reads 31-bit character; offset in 4-byte words.")+  , ("MutVar#","A @MutVar\\#@ behaves like a single-element mutable array.")+  , ("newMutVar#","Create @MutVar\\#@ with specified initial value in specified state thread.")+  , ("readMutVar#","Read contents of @MutVar\\#@. Result is not yet evaluated.")+  , ("writeMutVar#","Write contents of @MutVar\\#@.")+  , ("atomicModifyMutVar2#"," Modify the contents of a @MutVar\\#@, returning the previous\n     contents and the result of applying the given function to the\n     previous contents. Note that this isn't strictly\n     speaking the correct type for this function; it should really be\n     @MutVar\\# s a -> (a -> (a,b)) -> State\\# s -> (\\# State\\# s, a, (a, b) \\#)@,\n     but we don't know about pairs here. ")+  , ("atomicModifyMutVar_#"," Modify the contents of a @MutVar\\#@, returning the previous\n     contents and the result of applying the given function to the\n     previous contents. ")+  , ("raiseDivZero#","Raise a 'DivideByZero' arithmetic exception.")+  , ("raiseUnderflow#","Raise an 'Underflow' arithmetic exception.")+  , ("raiseOverflow#","Raise an 'Overflow' arithmetic exception.")+  , ("newTVar#","Create a new @TVar\\#@ holding a specified initial value.")+  , ("readTVar#","Read contents of @TVar\\#@.  Result is not yet evaluated.")+  , ("readTVarIO#","Read contents of @TVar\\#@ outside an STM transaction")+  , ("writeTVar#","Write contents of @TVar\\#@.")+  , ("MVar#"," A shared mutable variable (/not/ the same as a @MutVar\\#@!).\n        (Note: in a non-concurrent implementation, @(MVar\\# a)@ can be\n        represented by @(MutVar\\# (Maybe a))@.) ")+  , ("newMVar#","Create new @MVar\\#@; initially empty.")+  , ("takeMVar#","If @MVar\\#@ is empty, block until it becomes full.\n   Then remove and return its contents, and set it empty.")+  , ("tryTakeMVar#","If @MVar\\#@ is empty, immediately return with integer 0 and value undefined.\n   Otherwise, return with integer 1 and contents of @MVar\\#@, and set @MVar\\#@ empty.")+  , ("putMVar#","If @MVar\\#@ is full, block until it becomes empty.\n   Then store value arg as its new contents.")+  , ("tryPutMVar#","If @MVar\\#@ is full, immediately return with integer 0.\n    Otherwise, store value arg as @MVar\\#@'s new contents, and return with integer 1.")+  , ("readMVar#","If @MVar\\#@ is empty, block until it becomes full.\n   Then read its contents without modifying the MVar, without possibility\n   of intervention from other threads.")+  , ("tryReadMVar#","If @MVar\\#@ is empty, immediately return with integer 0 and value undefined.\n   Otherwise, return with integer 1 and contents of @MVar\\#@.")+  , ("isEmptyMVar#","Return 1 if @MVar\\#@ is empty; 0 otherwise.")+  , ("delay#","Sleep specified number of microseconds.")+  , ("waitRead#","Block until input is available on specified file descriptor.")+  , ("waitWrite#","Block until output is possible on specified file descriptor.")+  , ("State#"," @State\\#@ is the primitive, unlifted type of states.  It has\n        one type parameter, thus @State\\# RealWorld@, or @State\\# s@,\n        where s is a type variable. The only purpose of the type parameter\n        is to keep different state threads separate.  It is represented by\n        nothing at all. ")+  , ("RealWorld"," @RealWorld@ is deeply magical.  It is /primitive/, but it is not\n        /unlifted/ (hence @ptrArg@).  We never manipulate values of type\n        @RealWorld@; it's only used in the type system, to parameterise @State\\#@. ")+  , ("ThreadId#","(In a non-concurrent implementation, this can be a singleton\n        type, whose (unique) value is returned by @myThreadId\\#@.  The\n        other operations can be omitted.)")+  , ("mkWeak#"," @mkWeak# k v finalizer s@ creates a weak reference to value @k@,\n     with an associated reference to some value @v@. If @k@ is still\n     alive then @v@ can be retrieved using @deRefWeak#@. Note that\n     the type of @k@ must be represented by a pointer (i.e. of kind @TYPE 'LiftedRep@ or @TYPE 'UnliftedRep@). ")+  , ("addCFinalizerToWeak#"," @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C\n     function pointer @fptr@ to a weak pointer @w@ as a finalizer. If\n     @flag@ is zero, @fptr@ will be called with one argument,\n     @ptr@. Otherwise, it will be called with two arguments,\n     @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns\n     1 on success, or 0 if @w@ is already dead. ")+  , ("finalizeWeak#"," Finalize a weak pointer. The return value is an unboxed tuple\n     containing the new state of the world and an \"unboxed Maybe\",\n     represented by an @Int#@ and a (possibly invalid) finalization\n     action. An @Int#@ of @1@ indicates that the finalizer is valid. The\n     return value @b@ from the finalizer should be ignored. ")+  , ("compactNew#"," Create a new CNF with a single compact block. The argument is\n     the capacity of the compact block (in bytes, not words).\n     The capacity is rounded up to a multiple of the allocator block size\n     and is capped to one mega block. ")+  , ("compactResize#"," Set the new allocation size of the CNF. This value (in bytes)\n     determines the capacity of each compact block in the CNF. It\n     does not retroactively affect existing compact blocks in the CNF. ")+  , ("compactContains#"," Returns 1\\# if the object is contained in the CNF, 0\\# otherwise. ")+  , ("compactContainsAny#"," Returns 1\\# if the object is in any CNF at all, 0\\# otherwise. ")+  , ("compactGetFirstBlock#"," Returns the address and the utilized size (in bytes) of the\n     first compact block of a CNF.")+  , ("compactGetNextBlock#"," Given a CNF and the address of one its compact blocks, returns the\n     next compact block and its utilized size, or @nullAddr\\#@ if the\n     argument was the last compact block in the CNF. ")+  , ("compactAllocateBlock#"," Attempt to allocate a compact block with the capacity (in\n     bytes) given by the first argument. The @Addr\\#@ is a pointer\n     to previous compact block of the CNF or @nullAddr\\#@ to create a\n     new CNF with a single compact block.\n\n     The resulting block is not known to the GC until\n     @compactFixupPointers\\#@ is called on it, and care must be taken\n     so that the address does not escape or memory will be leaked.\n   ")+  , ("compactFixupPointers#"," Given the pointer to the first block of a CNF and the\n     address of the root object in the old address space, fix up\n     the internal pointers inside the CNF to account for\n     a different position in memory than when it was serialized.\n     This method must be called exactly once after importing\n     a serialized CNF. It returns the new CNF and the new adjusted\n     root address. ")+  , ("compactAdd#"," Recursively add a closure and its transitive closure to a\n     @Compact\\#@ (a CNF), evaluating any unevaluated components\n     at the same time. Note: @compactAdd\\#@ is not thread-safe, so\n     only one thread may call @compactAdd\\#@ with a particular\n     @Compact\\#@ at any given time. The primop does not\n     enforce any mutual exclusion; the caller is expected to\n     arrange this. ")+  , ("compactAddWithSharing#"," Like @compactAdd\\#@, but retains sharing and cycles\n   during compaction. ")+  , ("compactSize#"," Return the total capacity (in bytes) of all the compact blocks\n     in the CNF. ")+  , ("reallyUnsafePtrEquality#"," Returns @1\\#@ if the given pointers are equal and @0\\#@ otherwise. ")+  , ("numSparks#"," Returns the number of sparks in the local spark pool. ")+  , ("BCO"," Primitive bytecode type. ")+  , ("addrToAny#"," Convert an @Addr\\#@ to a followable Any type. ")+  , ("anyToAddr#"," Retrieve the address of any Haskell value. This is\n     essentially an @unsafeCoerce\\#@, but if implemented as such\n     the core lint pass complains and fails to compile.\n     As a primop, it is opaque to core/stg, and only appears\n     in cmm (where the copy propagation pass will get rid of it).\n     Note that \"a\" must be a value, not a thunk! It's too late\n     for strictness analysis to enforce this, so you're on your\n     own to guarantee this. Also note that @Addr\\#@ is not a GC\n     pointer - up to you to guarantee that it does not become\n     a dangling pointer immediately after you get it.")+  , ("mkApUpd0#"," Wrap a BCO in a @AP_UPD@ thunk which will be updated with the value of\n     the BCO when evaluated. ")+  , ("newBCO#"," @newBCO\\# instrs lits ptrs arity bitmap@ creates a new bytecode object. The\n     resulting object encodes a function of the given arity with the instructions\n     encoded in @instrs@, and a static reference table usage bitmap given by\n     @bitmap@. ")+  , ("unpackClosure#"," @unpackClosure\\# closure@ copies the closure and pointers in the\n     payload of the given closure into two new arrays, and returns a pointer to\n     the first word of the closure's info table, a non-pointer array for the raw\n     bytes of the closure, and a pointer array for the pointers in the payload. ")+  , ("closureSize#"," @closureSize\\# closure@ returns the size of the given closure in\n     machine words. ")+  , ("getCurrentCCS#"," Returns the current @CostCentreStack@ (value is @NULL@ if\n     not profiling).  Takes a dummy argument which can be used to\n     avoid the call to @getCurrentCCS\\#@ being floated out by the\n     simplifier, which would result in an uninformative stack\n     (\"CAF\"). ")+  , ("clearCCS#"," Run the supplied IO action with an empty CCS.  For example, this\n     is used by the interpreter to run an interpreted computation\n     without the call stack showing that it was invoked from GHC. ")+  , ("Proxy#"," The type constructor @Proxy#@ is used to bear witness to some\n   type variable. It's used when you want to pass around proxy values\n   for doing things like modelling type applications. A @Proxy#@\n   is not only unboxed, it also has a polymorphic kind, and has no\n   runtime representation, being totally free. ")+  , ("proxy#"," Witness for an unboxed @Proxy#@ value, which has no runtime\n   representation. ")+  , ("seq"," The value of @seq a b@ is bottom if @a@ is bottom, and\n     otherwise equal to @b@. In other words, it evaluates the first\n     argument @a@ to weak head normal form (WHNF). @seq@ is usually\n     introduced to improve performance by avoiding unneeded laziness.\n\n     A note on evaluation order: the expression @seq a b@ does\n     /not/ guarantee that @a@ will be evaluated before @b@.\n     The only guarantee given by @seq@ is that the both @a@\n     and @b@ will be evaluated before @seq@ returns a value.\n     In particular, this means that @b@ may be evaluated before\n     @a@. If you need to guarantee a specific order of evaluation,\n     you must use the function @pseq@ from the \"parallel\" package. ")+  , ("unsafeCoerce#"," The function @unsafeCoerce\\#@ allows you to side-step the typechecker entirely. That\n        is, it allows you to coerce any type into any other type. If you use this function,\n        you had better get it right, otherwise segmentation faults await. It is generally\n        used when you want to write a program that you know is well-typed, but where Haskell's\n        type system is not expressive enough to prove that it is well typed.\n\n        The following uses of @unsafeCoerce\\#@ are supposed to work (i.e. not lead to\n        spurious compile-time or run-time crashes):\n\n         * Casting any lifted type to @Any@\n\n         * Casting @Any@ back to the real type\n\n         * Casting an unboxed type to another unboxed type of the same size.\n           (Casting between floating-point and integral types does not work.\n           See the @GHC.Float@ module for functions to do work.)\n\n         * Casting between two types that have the same runtime representation.  One case is when\n           the two types differ only in \"phantom\" type parameters, for example\n           @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is\n           known to be empty.  Also, a @newtype@ of a type @T@ has the same representation\n           at runtime as @T@.\n\n        Other uses of @unsafeCoerce\\#@ are undefined.  In particular, you should not use\n        @unsafeCoerce\\#@ to cast a T to an algebraic data type D, unless T is also\n        an algebraic data type.  For example, do not cast @Int->Int@ to @Bool@, even if\n        you later cast that @Bool@ back to @Int->Int@ before applying it.  The reasons\n        have to do with GHC's internal representation details (for the cognoscenti, data values\n        can be entered but function closures cannot).  If you want a safe type to cast things\n        to, use @Any@, which is not an algebraic data type.\n\n        ")+  , ("traceEvent#"," Emits an event via the RTS tracing framework.  The contents\n     of the event is the zero-terminated byte string passed as the first\n     argument.  The event will be emitted either to the @.eventlog@ file,\n     or to stderr, depending on the runtime RTS flags. ")+  , ("traceBinaryEvent#"," Emits an event via the RTS tracing framework.  The contents\n     of the event is the binary object passed as the first argument with\n     the the given length passed as the second argument. The event will be\n     emitted to the @.eventlog@ file. ")+  , ("traceMarker#"," Emits a marker event via the RTS tracing framework.  The contents\n     of the event is the zero-terminated byte string passed as the first\n     argument.  The event will be emitted either to the @.eventlog@ file,\n     or to stderr, depending on the runtime RTS flags. ")+  , ("setThreadAllocationCounter#"," Sets the allocation counter for the current thread to the given value. ")+  , ("coerce"," The function @coerce@ allows you to safely convert between values of\n     types that have the same representation with no run-time overhead. In the\n     simplest case you can use it instead of a newtype constructor, to go from\n     the newtype's concrete type to the abstract type. But it also works in\n     more complicated settings, e.g. converting a list of newtypes to a list of\n     concrete types.\n\n     This function is runtime-representation polymorphic, but the\n     @RuntimeRep@ type argument is marked as @Inferred@, meaning\n     that it is not available for visible type application. This means\n     the typechecker will accept @coerce @Int @Age 42@.\n   ")+  , ("broadcastInt8X16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt16X8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt32X4#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt64X2#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt8X32#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt16X16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt32X8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt64X4#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt8X64#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt16X32#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt32X16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastInt64X8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord8X16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord16X8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord32X4#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord64X2#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord8X32#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord16X16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord32X8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord64X4#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord8X64#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord16X32#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord32X16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastWord64X8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastFloatX4#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastDoubleX2#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastFloatX8#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastDoubleX4#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastFloatX16#"," Broadcast a scalar to all elements of a vector. ")+  , ("broadcastDoubleX8#"," Broadcast a scalar to all elements of a vector. ")+  , ("packInt8X16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt16X8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt32X4#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt64X2#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt8X32#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt16X16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt32X8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt64X4#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt8X64#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt16X32#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt32X16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packInt64X8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord8X16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord16X8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord32X4#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord64X2#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord8X32#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord16X16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord32X8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord64X4#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord8X64#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord16X32#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord32X16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packWord64X8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packFloatX4#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packDoubleX2#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packFloatX8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packDoubleX4#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packFloatX16#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("packDoubleX8#"," Pack the elements of an unboxed tuple into a vector. ")+  , ("unpackInt8X16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt16X8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt32X4#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt64X2#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt8X32#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt16X16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt32X8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt64X4#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt8X64#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt16X32#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt32X16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackInt64X8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord8X16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord16X8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord32X4#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord64X2#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord8X32#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord16X16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord32X8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord64X4#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord8X64#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord16X32#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord32X16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackWord64X8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackFloatX4#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackDoubleX2#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackFloatX8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackDoubleX4#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackFloatX16#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("unpackDoubleX8#"," Unpack the elements of a vector into an unboxed tuple. #")+  , ("insertInt8X16#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt16X8#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt32X4#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt64X2#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt8X32#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt16X16#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt32X8#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt64X4#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt8X64#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt16X32#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt32X16#"," Insert a scalar at the given position in a vector. ")+  , ("insertInt64X8#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord8X16#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord16X8#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord32X4#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord64X2#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord8X32#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord16X16#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord32X8#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord64X4#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord8X64#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord16X32#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord32X16#"," Insert a scalar at the given position in a vector. ")+  , ("insertWord64X8#"," Insert a scalar at the given position in a vector. ")+  , ("insertFloatX4#"," Insert a scalar at the given position in a vector. ")+  , ("insertDoubleX2#"," Insert a scalar at the given position in a vector. ")+  , ("insertFloatX8#"," Insert a scalar at the given position in a vector. ")+  , ("insertDoubleX4#"," Insert a scalar at the given position in a vector. ")+  , ("insertFloatX16#"," Insert a scalar at the given position in a vector. ")+  , ("insertDoubleX8#"," Insert a scalar at the given position in a vector. ")+  , ("plusInt8X16#"," Add two vectors element-wise. ")+  , ("plusInt16X8#"," Add two vectors element-wise. ")+  , ("plusInt32X4#"," Add two vectors element-wise. ")+  , ("plusInt64X2#"," Add two vectors element-wise. ")+  , ("plusInt8X32#"," Add two vectors element-wise. ")+  , ("plusInt16X16#"," Add two vectors element-wise. ")+  , ("plusInt32X8#"," Add two vectors element-wise. ")+  , ("plusInt64X4#"," Add two vectors element-wise. ")+  , ("plusInt8X64#"," Add two vectors element-wise. ")+  , ("plusInt16X32#"," Add two vectors element-wise. ")+  , ("plusInt32X16#"," Add two vectors element-wise. ")+  , ("plusInt64X8#"," Add two vectors element-wise. ")+  , ("plusWord8X16#"," Add two vectors element-wise. ")+  , ("plusWord16X8#"," Add two vectors element-wise. ")+  , ("plusWord32X4#"," Add two vectors element-wise. ")+  , ("plusWord64X2#"," Add two vectors element-wise. ")+  , ("plusWord8X32#"," Add two vectors element-wise. ")+  , ("plusWord16X16#"," Add two vectors element-wise. ")+  , ("plusWord32X8#"," Add two vectors element-wise. ")+  , ("plusWord64X4#"," Add two vectors element-wise. ")+  , ("plusWord8X64#"," Add two vectors element-wise. ")+  , ("plusWord16X32#"," Add two vectors element-wise. ")+  , ("plusWord32X16#"," Add two vectors element-wise. ")+  , ("plusWord64X8#"," Add two vectors element-wise. ")+  , ("plusFloatX4#"," Add two vectors element-wise. ")+  , ("plusDoubleX2#"," Add two vectors element-wise. ")+  , ("plusFloatX8#"," Add two vectors element-wise. ")+  , ("plusDoubleX4#"," Add two vectors element-wise. ")+  , ("plusFloatX16#"," Add two vectors element-wise. ")+  , ("plusDoubleX8#"," Add two vectors element-wise. ")+  , ("minusInt8X16#"," Subtract two vectors element-wise. ")+  , ("minusInt16X8#"," Subtract two vectors element-wise. ")+  , ("minusInt32X4#"," Subtract two vectors element-wise. ")+  , ("minusInt64X2#"," Subtract two vectors element-wise. ")+  , ("minusInt8X32#"," Subtract two vectors element-wise. ")+  , ("minusInt16X16#"," Subtract two vectors element-wise. ")+  , ("minusInt32X8#"," Subtract two vectors element-wise. ")+  , ("minusInt64X4#"," Subtract two vectors element-wise. ")+  , ("minusInt8X64#"," Subtract two vectors element-wise. ")+  , ("minusInt16X32#"," Subtract two vectors element-wise. ")+  , ("minusInt32X16#"," Subtract two vectors element-wise. ")+  , ("minusInt64X8#"," Subtract two vectors element-wise. ")+  , ("minusWord8X16#"," Subtract two vectors element-wise. ")+  , ("minusWord16X8#"," Subtract two vectors element-wise. ")+  , ("minusWord32X4#"," Subtract two vectors element-wise. ")+  , ("minusWord64X2#"," Subtract two vectors element-wise. ")+  , ("minusWord8X32#"," Subtract two vectors element-wise. ")+  , ("minusWord16X16#"," Subtract two vectors element-wise. ")+  , ("minusWord32X8#"," Subtract two vectors element-wise. ")+  , ("minusWord64X4#"," Subtract two vectors element-wise. ")+  , ("minusWord8X64#"," Subtract two vectors element-wise. ")+  , ("minusWord16X32#"," Subtract two vectors element-wise. ")+  , ("minusWord32X16#"," Subtract two vectors element-wise. ")+  , ("minusWord64X8#"," Subtract two vectors element-wise. ")+  , ("minusFloatX4#"," Subtract two vectors element-wise. ")+  , ("minusDoubleX2#"," Subtract two vectors element-wise. ")+  , ("minusFloatX8#"," Subtract two vectors element-wise. ")+  , ("minusDoubleX4#"," Subtract two vectors element-wise. ")+  , ("minusFloatX16#"," Subtract two vectors element-wise. ")+  , ("minusDoubleX8#"," Subtract two vectors element-wise. ")+  , ("timesInt8X16#"," Multiply two vectors element-wise. ")+  , ("timesInt16X8#"," Multiply two vectors element-wise. ")+  , ("timesInt32X4#"," Multiply two vectors element-wise. ")+  , ("timesInt64X2#"," Multiply two vectors element-wise. ")+  , ("timesInt8X32#"," Multiply two vectors element-wise. ")+  , ("timesInt16X16#"," Multiply two vectors element-wise. ")+  , ("timesInt32X8#"," Multiply two vectors element-wise. ")+  , ("timesInt64X4#"," Multiply two vectors element-wise. ")+  , ("timesInt8X64#"," Multiply two vectors element-wise. ")+  , ("timesInt16X32#"," Multiply two vectors element-wise. ")+  , ("timesInt32X16#"," Multiply two vectors element-wise. ")+  , ("timesInt64X8#"," Multiply two vectors element-wise. ")+  , ("timesWord8X16#"," Multiply two vectors element-wise. ")+  , ("timesWord16X8#"," Multiply two vectors element-wise. ")+  , ("timesWord32X4#"," Multiply two vectors element-wise. ")+  , ("timesWord64X2#"," Multiply two vectors element-wise. ")+  , ("timesWord8X32#"," Multiply two vectors element-wise. ")+  , ("timesWord16X16#"," Multiply two vectors element-wise. ")+  , ("timesWord32X8#"," Multiply two vectors element-wise. ")+  , ("timesWord64X4#"," Multiply two vectors element-wise. ")+  , ("timesWord8X64#"," Multiply two vectors element-wise. ")+  , ("timesWord16X32#"," Multiply two vectors element-wise. ")+  , ("timesWord32X16#"," Multiply two vectors element-wise. ")+  , ("timesWord64X8#"," Multiply two vectors element-wise. ")+  , ("timesFloatX4#"," Multiply two vectors element-wise. ")+  , ("timesDoubleX2#"," Multiply two vectors element-wise. ")+  , ("timesFloatX8#"," Multiply two vectors element-wise. ")+  , ("timesDoubleX4#"," Multiply two vectors element-wise. ")+  , ("timesFloatX16#"," Multiply two vectors element-wise. ")+  , ("timesDoubleX8#"," Multiply two vectors element-wise. ")+  , ("divideFloatX4#"," Divide two vectors element-wise. ")+  , ("divideDoubleX2#"," Divide two vectors element-wise. ")+  , ("divideFloatX8#"," Divide two vectors element-wise. ")+  , ("divideDoubleX4#"," Divide two vectors element-wise. ")+  , ("divideFloatX16#"," Divide two vectors element-wise. ")+  , ("divideDoubleX8#"," Divide two vectors element-wise. ")+  , ("quotInt8X16#"," Rounds towards zero element-wise. ")+  , ("quotInt16X8#"," Rounds towards zero element-wise. ")+  , ("quotInt32X4#"," Rounds towards zero element-wise. ")+  , ("quotInt64X2#"," Rounds towards zero element-wise. ")+  , ("quotInt8X32#"," Rounds towards zero element-wise. ")+  , ("quotInt16X16#"," Rounds towards zero element-wise. ")+  , ("quotInt32X8#"," Rounds towards zero element-wise. ")+  , ("quotInt64X4#"," Rounds towards zero element-wise. ")+  , ("quotInt8X64#"," Rounds towards zero element-wise. ")+  , ("quotInt16X32#"," Rounds towards zero element-wise. ")+  , ("quotInt32X16#"," Rounds towards zero element-wise. ")+  , ("quotInt64X8#"," Rounds towards zero element-wise. ")+  , ("quotWord8X16#"," Rounds towards zero element-wise. ")+  , ("quotWord16X8#"," Rounds towards zero element-wise. ")+  , ("quotWord32X4#"," Rounds towards zero element-wise. ")+  , ("quotWord64X2#"," Rounds towards zero element-wise. ")+  , ("quotWord8X32#"," Rounds towards zero element-wise. ")+  , ("quotWord16X16#"," Rounds towards zero element-wise. ")+  , ("quotWord32X8#"," Rounds towards zero element-wise. ")+  , ("quotWord64X4#"," Rounds towards zero element-wise. ")+  , ("quotWord8X64#"," Rounds towards zero element-wise. ")+  , ("quotWord16X32#"," Rounds towards zero element-wise. ")+  , ("quotWord32X16#"," Rounds towards zero element-wise. ")+  , ("quotWord64X8#"," Rounds towards zero element-wise. ")+  , ("remInt8X16#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt16X8#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt32X4#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt64X2#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt8X32#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt16X16#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt32X8#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt64X4#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt8X64#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt16X32#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt32X16#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remInt64X8#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord8X16#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord16X8#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord32X4#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord64X2#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord8X32#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord16X16#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord32X8#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord64X4#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord8X64#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord16X32#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord32X16#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("remWord64X8#"," Satisfies @(quot\\# x y) times\\# y plus\\# (rem\\# x y) == x@. ")+  , ("negateInt8X16#"," Negate element-wise. ")+  , ("negateInt16X8#"," Negate element-wise. ")+  , ("negateInt32X4#"," Negate element-wise. ")+  , ("negateInt64X2#"," Negate element-wise. ")+  , ("negateInt8X32#"," Negate element-wise. ")+  , ("negateInt16X16#"," Negate element-wise. ")+  , ("negateInt32X8#"," Negate element-wise. ")+  , ("negateInt64X4#"," Negate element-wise. ")+  , ("negateInt8X64#"," Negate element-wise. ")+  , ("negateInt16X32#"," Negate element-wise. ")+  , ("negateInt32X16#"," Negate element-wise. ")+  , ("negateInt64X8#"," Negate element-wise. ")+  , ("negateFloatX4#"," Negate element-wise. ")+  , ("negateDoubleX2#"," Negate element-wise. ")+  , ("negateFloatX8#"," Negate element-wise. ")+  , ("negateDoubleX4#"," Negate element-wise. ")+  , ("negateFloatX16#"," Negate element-wise. ")+  , ("negateDoubleX8#"," Negate element-wise. ")+  , ("indexInt8X16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt16X8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt32X4Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt64X2Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt8X32Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt16X16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt32X8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt64X4Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt8X64Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt16X32Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt32X16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexInt64X8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord8X16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord16X8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord32X4Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord64X2Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord8X32Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord16X16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord32X8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord64X4Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord8X64Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord16X32Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord32X16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexWord64X8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexFloatX4Array#"," Read a vector from specified index of immutable array. ")+  , ("indexDoubleX2Array#"," Read a vector from specified index of immutable array. ")+  , ("indexFloatX8Array#"," Read a vector from specified index of immutable array. ")+  , ("indexDoubleX4Array#"," Read a vector from specified index of immutable array. ")+  , ("indexFloatX16Array#"," Read a vector from specified index of immutable array. ")+  , ("indexDoubleX8Array#"," Read a vector from specified index of immutable array. ")+  , ("readInt8X16Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt16X8Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt32X4Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt64X2Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt8X32Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt16X16Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt32X8Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt64X4Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt8X64Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt16X32Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt32X16Array#"," Read a vector from specified index of mutable array. ")+  , ("readInt64X8Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord8X16Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord16X8Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord32X4Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord64X2Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord8X32Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord16X16Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord32X8Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord64X4Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord8X64Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord16X32Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord32X16Array#"," Read a vector from specified index of mutable array. ")+  , ("readWord64X8Array#"," Read a vector from specified index of mutable array. ")+  , ("readFloatX4Array#"," Read a vector from specified index of mutable array. ")+  , ("readDoubleX2Array#"," Read a vector from specified index of mutable array. ")+  , ("readFloatX8Array#"," Read a vector from specified index of mutable array. ")+  , ("readDoubleX4Array#"," Read a vector from specified index of mutable array. ")+  , ("readFloatX16Array#"," Read a vector from specified index of mutable array. ")+  , ("readDoubleX8Array#"," Read a vector from specified index of mutable array. ")+  , ("writeInt8X16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt16X8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt32X4Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt64X2Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt8X32Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt16X16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt32X8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt64X4Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt8X64Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt16X32Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt32X16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeInt64X8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord8X16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord16X8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord32X4Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord64X2Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord8X32Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord16X16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord32X8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord64X4Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord8X64Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord16X32Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord32X16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeWord64X8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeFloatX4Array#"," Write a vector to specified index of mutable array. ")+  , ("writeDoubleX2Array#"," Write a vector to specified index of mutable array. ")+  , ("writeFloatX8Array#"," Write a vector to specified index of mutable array. ")+  , ("writeDoubleX4Array#"," Write a vector to specified index of mutable array. ")+  , ("writeFloatX16Array#"," Write a vector to specified index of mutable array. ")+  , ("writeDoubleX8Array#"," Write a vector to specified index of mutable array. ")+  , ("indexInt8X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt16X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt32X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt64X2OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt8X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt16X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt32X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt64X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt8X64OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt16X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt32X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexInt64X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord8X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord16X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord32X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord64X2OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord8X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord16X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord32X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord64X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord8X64OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord16X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord32X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexWord64X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexFloatX4OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexDoubleX2OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexFloatX8OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexDoubleX4OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexFloatX16OffAddr#"," Reads vector; offset in bytes. ")+  , ("indexDoubleX8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt8X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt16X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt32X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt64X2OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt8X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt16X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt32X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt64X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt8X64OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt16X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt32X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readInt64X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord8X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord16X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord32X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord64X2OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord8X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord16X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord32X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord64X4OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord8X64OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord16X32OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord32X16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readWord64X8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readFloatX4OffAddr#"," Reads vector; offset in bytes. ")+  , ("readDoubleX2OffAddr#"," Reads vector; offset in bytes. ")+  , ("readFloatX8OffAddr#"," Reads vector; offset in bytes. ")+  , ("readDoubleX4OffAddr#"," Reads vector; offset in bytes. ")+  , ("readFloatX16OffAddr#"," Reads vector; offset in bytes. ")+  , ("readDoubleX8OffAddr#"," Reads vector; offset in bytes. ")+  , ("writeInt8X16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt16X8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt32X4OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt64X2OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt8X32OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt16X16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt32X8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt64X4OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt8X64OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt16X32OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt32X16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeInt64X8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord8X16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord16X8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord32X4OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord64X2OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord8X32OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord16X16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord32X8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord64X4OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord8X64OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord16X32OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord32X16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeWord64X8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeFloatX4OffAddr#"," Write vector; offset in bytes. ")+  , ("writeDoubleX2OffAddr#"," Write vector; offset in bytes. ")+  , ("writeFloatX8OffAddr#"," Write vector; offset in bytes. ")+  , ("writeDoubleX4OffAddr#"," Write vector; offset in bytes. ")+  , ("writeFloatX16OffAddr#"," Write vector; offset in bytes. ")+  , ("writeDoubleX8OffAddr#"," Write vector; offset in bytes. ")+  , ("indexInt8ArrayAsInt8X16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt16ArrayAsInt16X8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt32ArrayAsInt32X4#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt64ArrayAsInt64X2#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt8ArrayAsInt8X32#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt16ArrayAsInt16X16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt32ArrayAsInt32X8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt64ArrayAsInt64X4#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt8ArrayAsInt8X64#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt16ArrayAsInt16X32#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt32ArrayAsInt32X16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexInt64ArrayAsInt64X8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord8ArrayAsWord8X16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord16ArrayAsWord16X8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord32ArrayAsWord32X4#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord64ArrayAsWord64X2#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord8ArrayAsWord8X32#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord16ArrayAsWord16X16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord32ArrayAsWord32X8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord64ArrayAsWord64X4#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord8ArrayAsWord8X64#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord16ArrayAsWord16X32#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord32ArrayAsWord32X16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexWord64ArrayAsWord64X8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexFloatArrayAsFloatX4#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexDoubleArrayAsDoubleX2#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexFloatArrayAsFloatX8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexDoubleArrayAsDoubleX4#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexFloatArrayAsFloatX16#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("indexDoubleArrayAsDoubleX8#"," Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ")+  , ("readInt8ArrayAsInt8X16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt16ArrayAsInt16X8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt32ArrayAsInt32X4#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt64ArrayAsInt64X2#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt8ArrayAsInt8X32#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt16ArrayAsInt16X16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt32ArrayAsInt32X8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt64ArrayAsInt64X4#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt8ArrayAsInt8X64#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt16ArrayAsInt16X32#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt32ArrayAsInt32X16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readInt64ArrayAsInt64X8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord8ArrayAsWord8X16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord16ArrayAsWord16X8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord32ArrayAsWord32X4#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord64ArrayAsWord64X2#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord8ArrayAsWord8X32#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord16ArrayAsWord16X16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord32ArrayAsWord32X8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord64ArrayAsWord64X4#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord8ArrayAsWord8X64#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord16ArrayAsWord16X32#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord32ArrayAsWord32X16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readWord64ArrayAsWord64X8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readFloatArrayAsFloatX4#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readDoubleArrayAsDoubleX2#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readFloatArrayAsFloatX8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readDoubleArrayAsDoubleX4#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readFloatArrayAsFloatX16#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("readDoubleArrayAsDoubleX8#"," Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt8ArrayAsInt8X16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt16ArrayAsInt16X8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt32ArrayAsInt32X4#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt64ArrayAsInt64X2#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt8ArrayAsInt8X32#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt16ArrayAsInt16X16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt32ArrayAsInt32X8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt64ArrayAsInt64X4#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt8ArrayAsInt8X64#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt16ArrayAsInt16X32#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt32ArrayAsInt32X16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeInt64ArrayAsInt64X8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord8ArrayAsWord8X16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord16ArrayAsWord16X8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord32ArrayAsWord32X4#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord64ArrayAsWord64X2#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord8ArrayAsWord8X32#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord16ArrayAsWord16X16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord32ArrayAsWord32X8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord64ArrayAsWord64X4#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord8ArrayAsWord8X64#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord16ArrayAsWord16X32#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord32ArrayAsWord32X16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeWord64ArrayAsWord64X8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeFloatArrayAsFloatX4#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeDoubleArrayAsDoubleX2#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeFloatArrayAsFloatX8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeDoubleArrayAsDoubleX4#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeFloatArrayAsFloatX16#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("writeDoubleArrayAsDoubleX8#"," Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ")+  , ("indexInt8OffAddrAsInt8X16#"," Reads vector; offset in scalar elements. ")+  , ("indexInt16OffAddrAsInt16X8#"," Reads vector; offset in scalar elements. ")+  , ("indexInt32OffAddrAsInt32X4#"," Reads vector; offset in scalar elements. ")+  , ("indexInt64OffAddrAsInt64X2#"," Reads vector; offset in scalar elements. ")+  , ("indexInt8OffAddrAsInt8X32#"," Reads vector; offset in scalar elements. ")+  , ("indexInt16OffAddrAsInt16X16#"," Reads vector; offset in scalar elements. ")+  , ("indexInt32OffAddrAsInt32X8#"," Reads vector; offset in scalar elements. ")+  , ("indexInt64OffAddrAsInt64X4#"," Reads vector; offset in scalar elements. ")+  , ("indexInt8OffAddrAsInt8X64#"," Reads vector; offset in scalar elements. ")+  , ("indexInt16OffAddrAsInt16X32#"," Reads vector; offset in scalar elements. ")+  , ("indexInt32OffAddrAsInt32X16#"," Reads vector; offset in scalar elements. ")+  , ("indexInt64OffAddrAsInt64X8#"," Reads vector; offset in scalar elements. ")+  , ("indexWord8OffAddrAsWord8X16#"," Reads vector; offset in scalar elements. ")+  , ("indexWord16OffAddrAsWord16X8#"," Reads vector; offset in scalar elements. ")+  , ("indexWord32OffAddrAsWord32X4#"," Reads vector; offset in scalar elements. ")+  , ("indexWord64OffAddrAsWord64X2#"," Reads vector; offset in scalar elements. ")+  , ("indexWord8OffAddrAsWord8X32#"," Reads vector; offset in scalar elements. ")+  , ("indexWord16OffAddrAsWord16X16#"," Reads vector; offset in scalar elements. ")+  , ("indexWord32OffAddrAsWord32X8#"," Reads vector; offset in scalar elements. ")+  , ("indexWord64OffAddrAsWord64X4#"," Reads vector; offset in scalar elements. ")+  , ("indexWord8OffAddrAsWord8X64#"," Reads vector; offset in scalar elements. ")+  , ("indexWord16OffAddrAsWord16X32#"," Reads vector; offset in scalar elements. ")+  , ("indexWord32OffAddrAsWord32X16#"," Reads vector; offset in scalar elements. ")+  , ("indexWord64OffAddrAsWord64X8#"," Reads vector; offset in scalar elements. ")+  , ("indexFloatOffAddrAsFloatX4#"," Reads vector; offset in scalar elements. ")+  , ("indexDoubleOffAddrAsDoubleX2#"," Reads vector; offset in scalar elements. ")+  , ("indexFloatOffAddrAsFloatX8#"," Reads vector; offset in scalar elements. ")+  , ("indexDoubleOffAddrAsDoubleX4#"," Reads vector; offset in scalar elements. ")+  , ("indexFloatOffAddrAsFloatX16#"," Reads vector; offset in scalar elements. ")+  , ("indexDoubleOffAddrAsDoubleX8#"," Reads vector; offset in scalar elements. ")+  , ("readInt8OffAddrAsInt8X16#"," Reads vector; offset in scalar elements. ")+  , ("readInt16OffAddrAsInt16X8#"," Reads vector; offset in scalar elements. ")+  , ("readInt32OffAddrAsInt32X4#"," Reads vector; offset in scalar elements. ")+  , ("readInt64OffAddrAsInt64X2#"," Reads vector; offset in scalar elements. ")+  , ("readInt8OffAddrAsInt8X32#"," Reads vector; offset in scalar elements. ")+  , ("readInt16OffAddrAsInt16X16#"," Reads vector; offset in scalar elements. ")+  , ("readInt32OffAddrAsInt32X8#"," Reads vector; offset in scalar elements. ")+  , ("readInt64OffAddrAsInt64X4#"," Reads vector; offset in scalar elements. ")+  , ("readInt8OffAddrAsInt8X64#"," Reads vector; offset in scalar elements. ")+  , ("readInt16OffAddrAsInt16X32#"," Reads vector; offset in scalar elements. ")+  , ("readInt32OffAddrAsInt32X16#"," Reads vector; offset in scalar elements. ")+  , ("readInt64OffAddrAsInt64X8#"," Reads vector; offset in scalar elements. ")+  , ("readWord8OffAddrAsWord8X16#"," Reads vector; offset in scalar elements. ")+  , ("readWord16OffAddrAsWord16X8#"," Reads vector; offset in scalar elements. ")+  , ("readWord32OffAddrAsWord32X4#"," Reads vector; offset in scalar elements. ")+  , ("readWord64OffAddrAsWord64X2#"," Reads vector; offset in scalar elements. ")+  , ("readWord8OffAddrAsWord8X32#"," Reads vector; offset in scalar elements. ")+  , ("readWord16OffAddrAsWord16X16#"," Reads vector; offset in scalar elements. ")+  , ("readWord32OffAddrAsWord32X8#"," Reads vector; offset in scalar elements. ")+  , ("readWord64OffAddrAsWord64X4#"," Reads vector; offset in scalar elements. ")+  , ("readWord8OffAddrAsWord8X64#"," Reads vector; offset in scalar elements. ")+  , ("readWord16OffAddrAsWord16X32#"," Reads vector; offset in scalar elements. ")+  , ("readWord32OffAddrAsWord32X16#"," Reads vector; offset in scalar elements. ")+  , ("readWord64OffAddrAsWord64X8#"," Reads vector; offset in scalar elements. ")+  , ("readFloatOffAddrAsFloatX4#"," Reads vector; offset in scalar elements. ")+  , ("readDoubleOffAddrAsDoubleX2#"," Reads vector; offset in scalar elements. ")+  , ("readFloatOffAddrAsFloatX8#"," Reads vector; offset in scalar elements. ")+  , ("readDoubleOffAddrAsDoubleX4#"," Reads vector; offset in scalar elements. ")+  , ("readFloatOffAddrAsFloatX16#"," Reads vector; offset in scalar elements. ")+  , ("readDoubleOffAddrAsDoubleX8#"," Reads vector; offset in scalar elements. ")+  , ("writeInt8OffAddrAsInt8X16#"," Write vector; offset in scalar elements. ")+  , ("writeInt16OffAddrAsInt16X8#"," Write vector; offset in scalar elements. ")+  , ("writeInt32OffAddrAsInt32X4#"," Write vector; offset in scalar elements. ")+  , ("writeInt64OffAddrAsInt64X2#"," Write vector; offset in scalar elements. ")+  , ("writeInt8OffAddrAsInt8X32#"," Write vector; offset in scalar elements. ")+  , ("writeInt16OffAddrAsInt16X16#"," Write vector; offset in scalar elements. ")+  , ("writeInt32OffAddrAsInt32X8#"," Write vector; offset in scalar elements. ")+  , ("writeInt64OffAddrAsInt64X4#"," Write vector; offset in scalar elements. ")+  , ("writeInt8OffAddrAsInt8X64#"," Write vector; offset in scalar elements. ")+  , ("writeInt16OffAddrAsInt16X32#"," Write vector; offset in scalar elements. ")+  , ("writeInt32OffAddrAsInt32X16#"," Write vector; offset in scalar elements. ")+  , ("writeInt64OffAddrAsInt64X8#"," Write vector; offset in scalar elements. ")+  , ("writeWord8OffAddrAsWord8X16#"," Write vector; offset in scalar elements. ")+  , ("writeWord16OffAddrAsWord16X8#"," Write vector; offset in scalar elements. ")+  , ("writeWord32OffAddrAsWord32X4#"," Write vector; offset in scalar elements. ")+  , ("writeWord64OffAddrAsWord64X2#"," Write vector; offset in scalar elements. ")+  , ("writeWord8OffAddrAsWord8X32#"," Write vector; offset in scalar elements. ")+  , ("writeWord16OffAddrAsWord16X16#"," Write vector; offset in scalar elements. ")+  , ("writeWord32OffAddrAsWord32X8#"," Write vector; offset in scalar elements. ")+  , ("writeWord64OffAddrAsWord64X4#"," Write vector; offset in scalar elements. ")+  , ("writeWord8OffAddrAsWord8X64#"," Write vector; offset in scalar elements. ")+  , ("writeWord16OffAddrAsWord16X32#"," Write vector; offset in scalar elements. ")+  , ("writeWord32OffAddrAsWord32X16#"," Write vector; offset in scalar elements. ")+  , ("writeWord64OffAddrAsWord64X8#"," Write vector; offset in scalar elements. ")+  , ("writeFloatOffAddrAsFloatX4#"," Write vector; offset in scalar elements. ")+  , ("writeDoubleOffAddrAsDoubleX2#"," Write vector; offset in scalar elements. ")+  , ("writeFloatOffAddrAsFloatX8#"," Write vector; offset in scalar elements. ")+  , ("writeDoubleOffAddrAsDoubleX4#"," Write vector; offset in scalar elements. ")+  , ("writeFloatOffAddrAsFloatX16#"," Write vector; offset in scalar elements. ")+  , ("writeDoubleOffAddrAsDoubleX8#"," Write vector; offset in scalar elements. ")+  ]
ghc-lib/stage0/compiler/build/primop-strictness.hs-incl view
@@ -5,7 +5,6 @@ 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
ghc-lib/stage0/lib/DerivedConstants.h view
@@ -455,8 +455,8 @@ #define OFFSET_MessageBlackHole_bh 16 #define REP_MessageBlackHole_bh b64 #define MessageBlackHole_bh(__ptr__) REP_MessageBlackHole_bh[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_bh]-#define SIZEOF_StgCompactNFData_NoHdr 64-#define SIZEOF_StgCompactNFData (SIZEOF_StgHeader+64)+#define SIZEOF_StgCompactNFData_NoHdr 72+#define SIZEOF_StgCompactNFData (SIZEOF_StgHeader+72) #define OFFSET_StgCompactNFData_totalW 0 #define REP_StgCompactNFData_totalW b64 #define StgCompactNFData_totalW(__ptr__) REP_StgCompactNFData_totalW[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_totalW]
ghc-lib/stage0/lib/GHCConstantsHaskellExports.hs view
@@ -116,7 +116,6 @@     cLONG_LONG_SIZE,     bITMAP_BITS_SHIFT,     tAG_BITS,-    wORDS_BIGENDIAN,     dYNAMIC_BY_DEFAULT,     lDV_SHIFT,     iLDV_CREATE_MASK,
ghc-lib/stage0/lib/GHCConstantsHaskellType.hs view
@@ -123,7 +123,6 @@       pc_CLONG_LONG_SIZE :: Int,       pc_BITMAP_BITS_SHIFT :: Int,       pc_TAG_BITS :: Int,-      pc_WORDS_BIGENDIAN :: Bool,       pc_DYNAMIC_BY_DEFAULT :: Bool,       pc_LDV_SHIFT :: Int,       pc_ILDV_CREATE_MASK :: Integer,
ghc-lib/stage0/lib/GHCConstantsHaskellWrappers.hs view
@@ -234,8 +234,6 @@ bITMAP_BITS_SHIFT dflags = pc_BITMAP_BITS_SHIFT (platformConstants dflags) tAG_BITS :: DynFlags -> Int tAG_BITS dflags = pc_TAG_BITS (platformConstants dflags)-wORDS_BIGENDIAN :: DynFlags -> Bool-wORDS_BIGENDIAN dflags = pc_WORDS_BIGENDIAN (platformConstants dflags) dYNAMIC_BY_DEFAULT :: DynFlags -> Bool dYNAMIC_BY_DEFAULT dflags = pc_DYNAMIC_BY_DEFAULT (platformConstants dflags) lDV_SHIFT :: DynFlags -> Int
ghc-lib/stage0/lib/ghcversion.h view
@@ -6,7 +6,7 @@ #endif  #define __GLASGOW_HASKELL_PATCHLEVEL1__ 0-#define __GLASGOW_HASKELL_PATCHLEVEL2__ 20200331+#define __GLASGOW_HASKELL_PATCHLEVEL2__ 20200430  #define MIN_VERSION_GLASGOW_HASKELL(ma,mi,pl1,pl2) (\    ((ma)*100+(mi)) <  __GLASGOW_HASKELL__ || \
ghc-lib/stage0/lib/platformConstants view
@@ -123,7 +123,6 @@       pc_CLONG_LONG_SIZE = 8,       pc_BITMAP_BITS_SHIFT = 6,       pc_TAG_BITS = 3,-      pc_WORDS_BIGENDIAN = False,       pc_DYNAMIC_BY_DEFAULT = False,       pc_LDV_SHIFT = 30,       pc_ILDV_CREATE_MASK = 1152921503533105152,
ghc-lib/stage0/lib/settings view
@@ -26,6 +26,7 @@ ,("target os", "OSDarwin") ,("target arch", "ArchX86_64") ,("target word size", "8")+,("target word big endian", "NO") ,("target has GNU nonexec stack", "NO") ,("target has .ident directive", "YES") ,("target has subsections via symbols", "YES")
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   = "4b9c586472bf99425f7bbcf346472d7c54f05028"+cProjectGitCommitId   = "014ef4a3d9ee30b8add9118950f1f5007143bd1c"  cProjectVersion       :: String-cProjectVersion       = "8.11.0.20200331"+cProjectVersion       = "8.11.0.20200430"  cProjectVersionInt    :: String cProjectVersionInt    = "811"  cProjectPatchLevel    :: String-cProjectPatchLevel    = "020200331"+cProjectPatchLevel    = "020200430"  cProjectPatchLevel1   :: String cProjectPatchLevel1   = "0"  cProjectPatchLevel2   :: String-cProjectPatchLevel2   = "20200331"+cProjectPatchLevel2   = "20200430"
includes/CodeGen.Platform.hs view
@@ -2,7 +2,7 @@ import GHC.Cmm.Expr #if !(defined(MACHREGS_i386) || defined(MACHREGS_x86_64) \     || defined(MACHREGS_sparc) || defined(MACHREGS_powerpc))-import PlainPanic+import GHC.Utils.Panic.Plain #endif import GHC.Platform.Reg
libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs view
@@ -145,3 +145,7 @@    | CUSKs    | StandaloneKindSignatures    deriving (Eq, Enum, Show, Generic, Bounded)+-- 'Ord' and 'Bounded' are provided for GHC API users (see discussions+-- in https://gitlab.haskell.org/ghc/ghc/merge_requests/2707 and+-- https://gitlab.haskell.org/ghc/ghc/merge_requests/826).+instance Ord Extension where compare a b = compare (fromEnum a) (fromEnum b)
libraries/ghc-boot-th/GHC/Lexeme.hs view
@@ -18,7 +18,7 @@ import Data.Char  -- | Is this character acceptable in a symbol (after the first char)?--- See alexGetByte in Lexer.x+-- See alexGetByte in GHC.Parser.Lexer okSymChar :: Char -> Bool okSymChar c   | c `elem` "(),;[]`{}_\"'"
− libraries/ghc-boot/GHC/PackageDb.hs 
@@ -1,579 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE ConstraintKinds #-}-{-# LANGUAGE DataKinds #-}-{-# LANGUAGE DeriveFoldable #-}-{-# LANGUAGE DeriveFunctor #-}-{-# LANGUAGE DeriveTraversable #-}-{-# LANGUAGE FunctionalDependencies #-}-{-# LANGUAGE LambdaCase #-}-{-# LANGUAGE GADTs #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE StandaloneDeriving #-}-{-# LANGUAGE TupleSections #-}-{-# OPTIONS_GHC -fno-warn-name-shadowing #-}--------------------------------------------------------------------------------- |--- Module      :  GHC.PackageDb--- Copyright   :  (c) The University of Glasgow 2009, Duncan Coutts 2014------ Maintainer  :  ghc-devs@haskell.org--- Portability :  portable------ This module provides the view of GHC's database of registered packages that--- is shared between GHC the compiler\/library, and the ghc-pkg program. It--- defines the database format that is shared between GHC and ghc-pkg.------ The database format, and this library are constructed so that GHC does not--- have to depend on the Cabal library. The ghc-pkg program acts as the--- gateway between the external package format (which is defined by Cabal) and--- the internal package format which is specialised just for GHC.------ GHC the compiler only needs some of the information which is kept about--- registered packages, such as module names, various paths etc. On the other--- hand ghc-pkg has to keep all the information from Cabal packages and be able--- to regurgitate it for users and other tools.------ The first trick is that we duplicate some of the information in the package--- database. We essentially keep two versions of the database in one file, one--- version used only by ghc-pkg which keeps the full information (using the--- serialised form of the 'InstalledPackageInfo' type defined by the Cabal--- library); and a second version written by ghc-pkg and read by GHC which has--- just the subset of information that GHC needs.------ The second trick is that this module only defines in detail the format of--- the second version -- the bit GHC uses -- and the part managed by ghc-pkg--- is kept in the file but here we treat it as an opaque blob of data. That way--- this library avoids depending on Cabal.----module GHC.PackageDb (-       InstalledPackageInfo(..),-       DbModule(..),-       DbUnitId(..),-       BinaryStringRep(..),-       DbUnitIdModuleRep(..),-       emptyInstalledPackageInfo,-       PackageDbLock,-       lockPackageDb,-       unlockPackageDb,-       DbMode(..),-       DbOpenMode(..),-       isDbOpenReadMode,-       readPackageDbForGhc,-       readPackageDbForGhcPkg,-       writePackageDb-  ) where--import Prelude -- See note [Why do we import Prelude here?]-import Data.Version (Version(..))-import qualified Data.ByteString as BS-import qualified Data.ByteString.Char8 as BS.Char8-import qualified Data.ByteString.Lazy as BS.Lazy-import qualified Data.ByteString.Lazy.Internal as BS.Lazy (defaultChunkSize)-import qualified Data.Foldable as F-import qualified Data.Traversable as F-import Data.Binary as Bin-import Data.Binary.Put as Bin-import Data.Binary.Get as Bin-import Control.Exception as Exception-import Control.Monad (when)-import System.FilePath-import System.IO-import System.IO.Error-import GHC.IO.Exception (IOErrorType(InappropriateType))-import GHC.IO.Handle.Lock-import System.Directory----- | This is a subset of Cabal's 'InstalledPackageInfo', with just the bits--- that GHC is interested in.  See Cabal's documentation for a more detailed--- description of all of the fields.----data InstalledPackageInfo compid srcpkgid srcpkgname instunitid unitid modulename mod-   = InstalledPackageInfo {-       unitId             :: instunitid,-       componentId        :: compid,-       instantiatedWith   :: [(modulename, mod)],-       sourcePackageId    :: srcpkgid,-       packageName        :: srcpkgname,-       packageVersion     :: Version,-       sourceLibName      :: Maybe srcpkgname,-       abiHash            :: String,-       depends            :: [instunitid],-       -- | Like 'depends', but each dependency is annotated with the-       -- ABI hash we expect the dependency to respect.-       abiDepends         :: [(instunitid, String)],-       importDirs         :: [FilePath],-       hsLibraries        :: [String],-       extraLibraries     :: [String],-       extraGHCiLibraries :: [String],-       libraryDirs        :: [FilePath],-       libraryDynDirs     :: [FilePath],-       frameworks         :: [String],-       frameworkDirs      :: [FilePath],-       ldOptions          :: [String],-       ccOptions          :: [String],-       includes           :: [String],-       includeDirs        :: [FilePath],-       haddockInterfaces  :: [FilePath],-       haddockHTMLs       :: [FilePath],-       exposedModules     :: [(modulename, Maybe mod)],-       hiddenModules      :: [modulename],-       indefinite         :: Bool,-       exposed            :: Bool,-       trusted            :: Bool-     }-  deriving (Eq, Show)---- | A convenience constraint synonym for common constraints over parameters--- to 'InstalledPackageInfo'.-type RepInstalledPackageInfo compid srcpkgid srcpkgname instunitid unitid modulename mod =-    (BinaryStringRep srcpkgid, BinaryStringRep srcpkgname,-     BinaryStringRep modulename, BinaryStringRep compid,-     BinaryStringRep instunitid,-     DbUnitIdModuleRep instunitid compid unitid modulename mod)---- | A type-class for the types which can be converted into 'DbModule'/'DbUnitId'.--- There is only one type class because these types are mutually recursive.--- NB: The functional dependency helps out type inference in cases--- where types would be ambiguous.-class DbUnitIdModuleRep instunitid compid unitid modulename mod-    | mod -> unitid, unitid -> mod, mod -> modulename, unitid -> compid, unitid -> instunitid-    where-  fromDbModule :: DbModule instunitid compid unitid modulename mod -> mod-  toDbModule :: mod -> DbModule instunitid compid unitid modulename mod-  fromDbUnitId :: DbUnitId instunitid compid unitid modulename mod -> unitid-  toDbUnitId :: unitid -> DbUnitId instunitid compid unitid modulename mod---- | @ghc-boot@'s copy of 'Module', i.e. what is serialized to the database.--- Use 'DbUnitIdModuleRep' to convert it into an actual 'Module'.--- It has phantom type parameters as this is the most convenient way--- to avoid undecidable instances.-data DbModule instunitid compid unitid modulename mod-   = DbModule {-       dbModuleUnitId :: unitid,-       dbModuleName :: modulename-     }-   | DbModuleVar {-       dbModuleVarName :: modulename-     }-  deriving (Eq, Show)---- | @ghc-boot@'s copy of 'UnitId', i.e. what is serialized to the database.--- Use 'DbUnitIdModuleRep' to convert it into an actual 'UnitId'.--- It has phantom type parameters as this is the most convenient way--- to avoid undecidable instances.-data DbUnitId instunitid compid unitid modulename mod-   = DbUnitId compid [(modulename, mod)]-   | DbInstalledUnitId instunitid-  deriving (Eq, Show)--class BinaryStringRep a where-  fromStringRep :: BS.ByteString -> a-  toStringRep   :: a -> BS.ByteString--emptyInstalledPackageInfo :: RepInstalledPackageInfo a b c d e f g-                          => InstalledPackageInfo a b c d e f g-emptyInstalledPackageInfo =-  InstalledPackageInfo {-       unitId             = fromStringRep BS.empty,-       componentId        = fromStringRep BS.empty,-       instantiatedWith   = [],-       sourcePackageId    = fromStringRep BS.empty,-       packageName        = fromStringRep BS.empty,-       packageVersion     = Version [] [],-       sourceLibName      = Nothing,-       abiHash            = "",-       depends            = [],-       abiDepends         = [],-       importDirs         = [],-       hsLibraries        = [],-       extraLibraries     = [],-       extraGHCiLibraries = [],-       libraryDirs        = [],-       libraryDynDirs     = [],-       frameworks         = [],-       frameworkDirs      = [],-       ldOptions          = [],-       ccOptions          = [],-       includes           = [],-       includeDirs        = [],-       haddockInterfaces  = [],-       haddockHTMLs       = [],-       exposedModules     = [],-       hiddenModules      = [],-       indefinite         = False,-       exposed            = False,-       trusted            = False-  }---- | Represents a lock of a package db.-newtype PackageDbLock = PackageDbLock Handle---- | Acquire an exclusive lock related to package DB under given location.-lockPackageDb :: FilePath -> IO PackageDbLock---- | Release the lock related to package DB.-unlockPackageDb :: PackageDbLock -> IO ()---- | Acquire a lock of given type related to package DB under given location.-lockPackageDbWith :: LockMode -> FilePath -> IO PackageDbLock-lockPackageDbWith mode file = do-  -- We are trying to open the lock file and then lock it. Thus the lock file-  -- needs to either exist or we need to be able to create it. Ideally we-  -- would not assume that the lock file always exists in advance. When we are-  -- dealing with a package DB where we have write access then if the lock-  -- file does not exist then we can create it by opening the file in-  -- read/write mode. On the other hand if we are dealing with a package DB-  -- where we do not have write access (e.g. a global DB) then we can only-  -- open in read mode, and the lock file had better exist already or we're in-  -- trouble. So for global read-only DBs on platforms where we must lock the-  -- DB for reading then we will require that the installer/packaging has-  -- included the lock file.-  ---  -- Thus the logic here is to first try opening in read-write mode-  -- and if that fails we try read-only (to handle global read-only DBs).-  -- If either succeed then lock the file. IO exceptions (other than the first-  -- open attempt failing due to the file not existing) simply propagate.-  ---  -- Note that there is a complexity here which was discovered in #13945: some-  -- filesystems (e.g. NFS) will only allow exclusive locking if the fd was-  -- opened for write access. We would previously try opening the lockfile for-  -- read-only access first, however this failed when run on such filesystems.-  -- Consequently, we now try read-write access first, falling back to read-only-  -- if we are denied permission (e.g. in the case of a global database).-  catchJust-    (\e -> if isPermissionError e then Just () else Nothing)-    (lockFileOpenIn ReadWriteMode)-    (const $ lockFileOpenIn ReadMode)-  where-    lock = file <.> "lock"--    lockFileOpenIn io_mode = bracketOnError-      (openBinaryFile lock io_mode)-      hClose-      -- If file locking support is not available, ignore the error and proceed-      -- normally. Without it the only thing we lose on non-Windows platforms is-      -- the ability to safely issue concurrent updates to the same package db.-      $ \hnd -> do hLock hnd mode `catch` \FileLockingNotSupported -> return ()-                   return $ PackageDbLock hnd--lockPackageDb = lockPackageDbWith ExclusiveLock-unlockPackageDb (PackageDbLock hnd) = do-    hUnlock hnd-    hClose hnd---- | Mode to open a package db in.-data DbMode = DbReadOnly | DbReadWrite---- | 'DbOpenMode' holds a value of type @t@ but only in 'DbReadWrite' mode.  So--- it is like 'Maybe' but with a type argument for the mode to enforce that the--- mode is used consistently.-data DbOpenMode (mode :: DbMode) t where-  DbOpenReadOnly  ::      DbOpenMode 'DbReadOnly t-  DbOpenReadWrite :: t -> DbOpenMode 'DbReadWrite t--deriving instance Functor (DbOpenMode mode)-deriving instance F.Foldable (DbOpenMode mode)-deriving instance F.Traversable (DbOpenMode mode)--isDbOpenReadMode :: DbOpenMode mode t -> Bool-isDbOpenReadMode = \case-  DbOpenReadOnly    -> True-  DbOpenReadWrite{} -> False---- | Read the part of the package DB that GHC is interested in.----readPackageDbForGhc :: RepInstalledPackageInfo a b c d e f g =>-                       FilePath -> IO [InstalledPackageInfo a b c d e f g]-readPackageDbForGhc file =-  decodeFromFile file DbOpenReadOnly getDbForGhc >>= \case-    (pkgs, DbOpenReadOnly) -> return pkgs-  where-    getDbForGhc = do-      _version    <- getHeader-      _ghcPartLen <- get :: Get Word32-      ghcPart     <- get-      -- the next part is for ghc-pkg, but we stop here.-      return ghcPart---- | Read the part of the package DB that ghc-pkg is interested in------ Note that the Binary instance for ghc-pkg's representation of packages--- is not defined in this package. This is because ghc-pkg uses Cabal types--- (and Binary instances for these) which this package does not depend on.------ If we open the package db in read only mode, we get its contents. Otherwise--- we additionally receive a PackageDbLock that represents a lock on the--- database, so that we can safely update it later.----readPackageDbForGhcPkg :: Binary pkgs => FilePath -> DbOpenMode mode t ->-                          IO (pkgs, DbOpenMode mode PackageDbLock)-readPackageDbForGhcPkg file mode =-    decodeFromFile file mode getDbForGhcPkg-  where-    getDbForGhcPkg = do-      _version    <- getHeader-      -- skip over the ghc part-      ghcPartLen  <- get :: Get Word32-      _ghcPart    <- skip (fromIntegral ghcPartLen)-      -- the next part is for ghc-pkg-      ghcPkgPart  <- get-      return ghcPkgPart---- | Write the whole of the package DB, both parts.----writePackageDb :: (Binary pkgs, RepInstalledPackageInfo a b c d e f g) =>-                  FilePath -> [InstalledPackageInfo a b c d e f g] ->-                  pkgs -> IO ()-writePackageDb file ghcPkgs ghcPkgPart =-  writeFileAtomic file (runPut putDbForGhcPkg)-  where-    putDbForGhcPkg = do-        putHeader-        put               ghcPartLen-        putLazyByteString ghcPart-        put               ghcPkgPart-      where-        ghcPartLen :: Word32-        ghcPartLen = fromIntegral (BS.Lazy.length ghcPart)-        ghcPart    = encode ghcPkgs--getHeader :: Get (Word32, Word32)-getHeader = do-    magic <- getByteString (BS.length headerMagic)-    when (magic /= headerMagic) $-      fail "not a ghc-pkg db file, wrong file magic number"--    majorVersion <- get :: Get Word32-    -- The major version is for incompatible changes--    minorVersion <- get :: Get Word32-    -- The minor version is for compatible extensions--    when (majorVersion /= 1) $-      fail "unsupported ghc-pkg db format version"-    -- If we ever support multiple major versions then we'll have to change-    -- this code--    -- The header can be extended without incrementing the major version,-    -- we ignore fields we don't know about (currently all).-    headerExtraLen <- get :: Get Word32-    skip (fromIntegral headerExtraLen)--    return (majorVersion, minorVersion)--putHeader :: Put-putHeader = do-    putByteString headerMagic-    put majorVersion-    put minorVersion-    put headerExtraLen-  where-    majorVersion   = 1 :: Word32-    minorVersion   = 0 :: Word32-    headerExtraLen = 0 :: Word32--headerMagic :: BS.ByteString-headerMagic = BS.Char8.pack "\0ghcpkg\0"----- TODO: we may be able to replace the following with utils from the binary--- package in future.---- | Feed a 'Get' decoder with data chunks from a file.----decodeFromFile :: FilePath -> DbOpenMode mode t -> Get pkgs ->-                  IO (pkgs, DbOpenMode mode PackageDbLock)-decodeFromFile file mode decoder = case mode of-  DbOpenReadOnly -> do-  -- Note [Locking package database on Windows]-  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-  -- When we open the package db in read only mode, there is no need to acquire-  -- shared lock on non-Windows platform because we update the database with an-  -- atomic rename, so readers will always see the database in a consistent-  -- state.-#if defined(mingw32_HOST_OS)-    bracket (lockPackageDbWith SharedLock file) unlockPackageDb $ \_ -> do-#endif-      (, DbOpenReadOnly) <$> decodeFileContents-  DbOpenReadWrite{} -> do-    -- When we open the package db in read/write mode, acquire an exclusive lock-    -- on the database and return it so we can keep it for the duration of the-    -- update.-    bracketOnError (lockPackageDb file) unlockPackageDb $ \lock -> do-      (, DbOpenReadWrite lock) <$> decodeFileContents-  where-    decodeFileContents = withBinaryFile file ReadMode $ \hnd ->-      feed hnd (runGetIncremental decoder)--    feed hnd (Partial k)  = do chunk <- BS.hGet hnd BS.Lazy.defaultChunkSize-                               if BS.null chunk-                                 then feed hnd (k Nothing)-                                 else feed hnd (k (Just chunk))-    feed _ (Done _ _ res) = return res-    feed _ (Fail _ _ msg) = ioError err-      where-        err = mkIOError InappropriateType loc Nothing (Just file)-              `ioeSetErrorString` msg-        loc = "GHC.PackageDb.readPackageDb"---- Copied from Cabal's Distribution.Simple.Utils.-writeFileAtomic :: FilePath -> BS.Lazy.ByteString -> IO ()-writeFileAtomic targetPath content = do-  let (targetDir, targetFile) = splitFileName targetPath-  Exception.bracketOnError-    (openBinaryTempFileWithDefaultPermissions targetDir $ targetFile <.> "tmp")-    (\(tmpPath, handle) -> hClose handle >> removeFile tmpPath)-    (\(tmpPath, handle) -> do-        BS.Lazy.hPut handle content-        hClose handle-        renameFile tmpPath targetPath)--instance (RepInstalledPackageInfo a b c d e f g) =>-         Binary (InstalledPackageInfo a b c d e f g) where-  put (InstalledPackageInfo-         unitId componentId instantiatedWith sourcePackageId-         packageName packageVersion-         sourceLibName-         abiHash depends abiDepends importDirs-         hsLibraries extraLibraries extraGHCiLibraries-         libraryDirs libraryDynDirs-         frameworks frameworkDirs-         ldOptions ccOptions-         includes includeDirs-         haddockInterfaces haddockHTMLs-         exposedModules hiddenModules-         indefinite exposed trusted) = do-    put (toStringRep sourcePackageId)-    put (toStringRep packageName)-    put packageVersion-    put (fmap toStringRep sourceLibName)-    put (toStringRep unitId)-    put (toStringRep componentId)-    put (map (\(mod_name, mod) -> (toStringRep mod_name, toDbModule mod))-             instantiatedWith)-    put abiHash-    put (map toStringRep depends)-    put (map (\(k,v) -> (toStringRep k, v)) abiDepends)-    put importDirs-    put hsLibraries-    put extraLibraries-    put extraGHCiLibraries-    put libraryDirs-    put libraryDynDirs-    put frameworks-    put frameworkDirs-    put ldOptions-    put ccOptions-    put includes-    put includeDirs-    put haddockInterfaces-    put haddockHTMLs-    put (map (\(mod_name, mb_mod) -> (toStringRep mod_name, fmap toDbModule mb_mod))-             exposedModules)-    put (map toStringRep hiddenModules)-    put indefinite-    put exposed-    put trusted--  get = do-    sourcePackageId    <- get-    packageName        <- get-    packageVersion     <- get-    sourceLibName      <- get-    unitId             <- get-    componentId        <- get-    instantiatedWith   <- get-    abiHash            <- get-    depends            <- get-    abiDepends         <- get-    importDirs         <- get-    hsLibraries        <- get-    extraLibraries     <- get-    extraGHCiLibraries <- get-    libraryDirs        <- get-    libraryDynDirs     <- get-    frameworks         <- get-    frameworkDirs      <- get-    ldOptions          <- get-    ccOptions          <- get-    includes           <- get-    includeDirs        <- get-    haddockInterfaces  <- get-    haddockHTMLs       <- get-    exposedModules     <- get-    hiddenModules      <- get-    indefinite         <- get-    exposed            <- get-    trusted            <- get-    return (InstalledPackageInfo-              (fromStringRep unitId)-              (fromStringRep componentId)-              (map (\(mod_name, mod) -> (fromStringRep mod_name, fromDbModule mod))-                instantiatedWith)-              (fromStringRep sourcePackageId)-              (fromStringRep packageName) packageVersion-              (fmap fromStringRep sourceLibName)-              abiHash-              (map fromStringRep depends)-              (map (\(k,v) -> (fromStringRep k, v)) abiDepends)-              importDirs-              hsLibraries extraLibraries extraGHCiLibraries-              libraryDirs libraryDynDirs-              frameworks frameworkDirs-              ldOptions ccOptions-              includes includeDirs-              haddockInterfaces haddockHTMLs-              (map (\(mod_name, mb_mod) ->-                        (fromStringRep mod_name, fmap fromDbModule mb_mod))-                   exposedModules)-              (map fromStringRep hiddenModules)-              indefinite exposed trusted)--instance (BinaryStringRep modulename, BinaryStringRep compid,-          BinaryStringRep instunitid,-          DbUnitIdModuleRep instunitid compid unitid modulename mod) =>-         Binary (DbModule instunitid compid unitid modulename mod) where-  put (DbModule dbModuleUnitId dbModuleName) = do-    putWord8 0-    put (toDbUnitId dbModuleUnitId)-    put (toStringRep dbModuleName)-  put (DbModuleVar dbModuleVarName) = do-    putWord8 1-    put (toStringRep dbModuleVarName)-  get = do-    b <- getWord8-    case b of-      0 -> do dbModuleUnitId <- get-              dbModuleName <- get-              return (DbModule (fromDbUnitId dbModuleUnitId)-                               (fromStringRep dbModuleName))-      _ -> do dbModuleVarName <- get-              return (DbModuleVar (fromStringRep dbModuleVarName))--instance (BinaryStringRep modulename, BinaryStringRep compid,-          BinaryStringRep instunitid,-          DbUnitIdModuleRep instunitid compid unitid modulename mod) =>-         Binary (DbUnitId instunitid compid unitid modulename mod) where-  put (DbInstalledUnitId instunitid) = do-    putWord8 0-    put (toStringRep instunitid)-  put (DbUnitId dbUnitIdComponentId dbUnitIdInsts) = do-    putWord8 1-    put (toStringRep dbUnitIdComponentId)-    put (map (\(mod_name, mod) -> (toStringRep mod_name, toDbModule mod)) dbUnitIdInsts)-  get = do-    b <- getWord8-    case b of-      0 -> do-        instunitid <- get-        return (DbInstalledUnitId (fromStringRep instunitid))-      _ -> do-        dbUnitIdComponentId <- get-        dbUnitIdInsts <- get-        return (DbUnitId-            (fromStringRep dbUnitIdComponentId)-            (map (\(mod_name, mod) -> ( fromStringRep mod_name-                                      , fromDbModule mod))-                 dbUnitIdInsts))
libraries/ghc-boot/GHC/Platform.hs view
@@ -2,42 +2,45 @@  -- | A description of the platform we're compiling for. ---module GHC.Platform (-        PlatformMini(..),-        PlatformWordSize(..),-        Platform(..), platformArch, platformOS,-        Arch(..),-        OS(..),-        ArmISA(..),-        ArmISAExt(..),-        ArmABI(..),-        PPC_64ABI(..),--        target32Bit,-        isARM,-        osElfTarget,-        osMachOTarget,-        osSubsectionsViaSymbols,-        platformUsesFrameworks,-        platformWordSizeInBytes,-        platformWordSizeInBits,-        platformMinInt,-        platformMaxInt,-        platformMaxWord,-        platformInIntRange,-        platformInWordRange,--        PlatformMisc(..),-        IntegerLibrary(..),--        stringEncodeArch,-        stringEncodeOS,+module GHC.Platform+   ( PlatformMini(..)+   , PlatformWordSize(..)+   , Platform(..)+   , platformArch+   , platformOS+   , Arch(..)+   , OS(..)+   , ArmISA(..)+   , ArmISAExt(..)+   , ArmABI(..)+   , PPC_64ABI(..)+   , ByteOrder(..)+   , target32Bit+   , isARM+   , osElfTarget+   , osMachOTarget+   , osSubsectionsViaSymbols+   , platformUsesFrameworks+   , platformWordSizeInBytes+   , platformWordSizeInBits+   , platformMinInt+   , platformMaxInt+   , platformMaxWord+   , platformInIntRange+   , platformInWordRange+   , PlatformMisc(..)+   , IntegerLibrary(..)+   , stringEncodeArch+   , stringEncodeOS+   , SseVersion (..)+   , BmiVersion (..) )  where  import Prelude -- See Note [Why do we import Prelude here?] import GHC.Read+import GHC.ByteOrder (ByteOrder(..)) import Data.Word import Data.Int @@ -53,19 +56,17 @@  -- | Contains enough information for the native code generator to emit --      code for this platform.-data Platform-        = Platform {-              platformMini                     :: PlatformMini,-              -- Word size in bytes (i.e. normally 4 or 8,-              -- for 32bit and 64bit platforms respectively)-              platformWordSize                 :: PlatformWordSize,-              platformUnregisterised           :: Bool,-              platformHasGnuNonexecStack       :: Bool,-              platformHasIdentDirective        :: Bool,-              platformHasSubsectionsViaSymbols :: Bool,-              platformIsCrossCompiling         :: Bool-          }-        deriving (Read, Show, Eq)+data Platform = Platform+   { platformMini                     :: PlatformMini+   , platformWordSize                 :: PlatformWordSize+   , platformByteOrder                :: ByteOrder+   , platformUnregisterised           :: Bool+   , platformHasGnuNonexecStack       :: Bool+   , platformHasIdentDirective        :: Bool+   , platformHasSubsectionsViaSymbols :: Bool+   , platformIsCrossCompiling         :: Bool+   }+   deriving (Read, Show, Eq)  data PlatformWordSize   = PW4 -- ^ A 32-bit platform@@ -338,3 +339,24 @@ -- | Test if the given Integer is representable with a platform Word platformInWordRange :: Platform -> Integer -> Bool platformInWordRange platform x = x >= 0 && x <= platformMaxWord platform+++--------------------------------------------------+-- Instruction sets+--------------------------------------------------++-- | x86 SSE instructions+data SseVersion+   = SSE1+   | SSE2+   | SSE3+   | SSE4+   | SSE42+   deriving (Eq, Ord)++-- | x86 BMI (bit manipulation) instructions+data BmiVersion+   = BMI1+   | BMI2+   deriving (Eq, Ord)+
+ libraries/ghc-boot/GHC/Unit/Database.hs view
@@ -0,0 +1,703 @@+{-# OPTIONS_GHC -fno-warn-name-shadowing #-}++{-# LANGUAGE CPP #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE TupleSections #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE ExplicitNamespaces #-}+{-# LANGUAGE RecordWildCards #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  GHC.Unit.Database+-- Copyright   :  (c) The University of Glasgow 2009, Duncan Coutts 2014+--+-- Maintainer  :  ghc-devs@haskell.org+-- Portability :  portable+--+-- This module provides the view of GHC's database of registered packages that+-- is shared between GHC the compiler\/library, and the ghc-pkg program. It+-- defines the database format that is shared between GHC and ghc-pkg.+--+-- The database format, and this library are constructed so that GHC does not+-- have to depend on the Cabal library. The ghc-pkg program acts as the+-- gateway between the external package format (which is defined by Cabal) and+-- the internal package format which is specialised just for GHC.+--+-- GHC the compiler only needs some of the information which is kept about+-- registered packages, such as module names, various paths etc. On the other+-- hand ghc-pkg has to keep all the information from Cabal packages and be able+-- to regurgitate it for users and other tools.+--+-- The first trick is that we duplicate some of the information in the package+-- database. We essentially keep two versions of the database in one file, one+-- version used only by ghc-pkg which keeps the full information (using the+-- serialised form of the 'InstalledPackageInfo' type defined by the Cabal+-- library); and a second version written by ghc-pkg and read by GHC which has+-- just the subset of information that GHC needs.+--+-- The second trick is that this module only defines in detail the format of+-- the second version -- the bit GHC uses -- and the part managed by ghc-pkg+-- is kept in the file but here we treat it as an opaque blob of data. That way+-- this library avoids depending on Cabal.+--+module GHC.Unit.Database+   ( GenericUnitInfo(..)+   , type DbUnitInfo+   , DbModule (..)+   , DbInstUnitId (..)+   , mapGenericUnitInfo+   -- * Read and write+   , DbMode(..)+   , DbOpenMode(..)+   , isDbOpenReadMode+   , readPackageDbForGhc+   , readPackageDbForGhcPkg+   , writePackageDb+   -- * Locking+   , PackageDbLock+   , lockPackageDb+   , unlockPackageDb+   -- * Misc+   , mkMungePathUrl+   , mungeUnitInfoPaths+   )+where++import Prelude -- See note [Why do we import Prelude here?]+import Data.Version (Version(..))+import qualified Data.ByteString as BS+import qualified Data.ByteString.Char8 as BS.Char8+import qualified Data.ByteString.Lazy as BS.Lazy+import qualified Data.ByteString.Lazy.Internal as BS.Lazy (defaultChunkSize)+import qualified Data.Foldable as F+import qualified Data.Traversable as F+import Data.Bifunctor+import Data.Binary as Bin+import Data.Binary.Put as Bin+import Data.Binary.Get as Bin+import Control.Exception as Exception+import Control.Monad (when)+import System.FilePath as FilePath+import qualified System.FilePath.Posix as FilePath.Posix+import System.IO+import System.IO.Error+import GHC.IO.Exception (IOErrorType(InappropriateType))+import GHC.IO.Handle.Lock+import System.Directory+import Data.List (stripPrefix)++-- | @ghc-boot@'s UnitInfo, serialized to the database.+type DbUnitInfo      = GenericUnitInfo BS.ByteString BS.ByteString BS.ByteString BS.ByteString BS.ByteString DbModule++-- | Information about an unit (a unit is an installed module library).+--+-- This is a subset of Cabal's 'InstalledPackageInfo', with just the bits+-- that GHC is interested in.+--+-- Some types are left as parameters to be instantiated differently in ghc-pkg+-- and in ghc itself.+--+data GenericUnitInfo compid srcpkgid srcpkgname uid modulename mod = GenericUnitInfo+   { unitId             :: uid+      -- ^ Unique unit identifier that is used during compilation (e.g. to+      -- generate symbols).++   , unitInstanceOf     :: compid+      -- ^ Identifier of an indefinite unit (i.e. with module holes) that this+      -- unit is an instance of.++   , unitInstantiations :: [(modulename, mod)]+      -- ^ How this unit instantiates some of its module holes. Map hole module+      -- names to actual module++   , unitPackageId      :: srcpkgid+      -- ^ Source package identifier.+      --+      -- Cabal instantiates this with Distribution.Types.PackageId.PackageId+      -- type which only contains the source package name and version. Notice+      -- that it doesn't contain the Hackage revision, nor any kind of hash.++   , unitPackageName    :: srcpkgname+      -- ^ Source package name++   , unitPackageVersion :: Version+      -- ^ Source package version++   , unitComponentName  :: Maybe srcpkgname+      -- ^ Name of the component.+      --+      -- Cabal supports more than one components (libraries, executables,+      -- testsuites) in the same package. Each component has a name except the+      -- default one (that can only be a library component) for which we use+      -- "Nothing".+      --+      -- GHC only deals with "library" components as they are the only kind of+      -- components that can be registered in a database and used by other+      -- modules.++   , unitAbiHash        :: String+      -- ^ ABI hash used to avoid mixing up units compiled with different+      -- dependencies, compiler, options, etc.++   , unitDepends        :: [uid]+      -- ^ Identifiers of the units this one depends on++   , unitAbiDepends     :: [(uid, String)]+     -- ^ Like 'unitDepends', but each dependency is annotated with the ABI hash+     -- we expect the dependency to respect.++   , unitImportDirs     :: [FilePath]+      -- ^ Directories containing module interfaces++   , unitLibraries      :: [String]+      -- ^ Names of the Haskell libraries provided by this unit++   , unitExtDepLibsSys  :: [String]+      -- ^ Names of the external system libraries that this unit depends on. See+      -- also `unitExtDepLibsGhc` field.++   , unitExtDepLibsGhc  :: [String]+      -- ^ Because of slight differences between the GHC dynamic linker (in+      -- GHC.Runtime.Linker) and the+      -- native system linker, some packages have to link with a different list+      -- of libraries when using GHC's. Examples include: libs that are actually+      -- gnu ld scripts, and the possibility that the .a libs do not exactly+      -- match the .so/.dll equivalents.+      --+      -- If this field is set, then we use that instead of the+      -- `unitExtDepLibsSys` field.++   , unitLibraryDirs    :: [FilePath]+      -- ^ Directories containing libraries provided by this unit. See also+      -- `unitLibraryDynDirs`.+      --+      -- It seems to be used to store paths to external library dependencies+      -- too.++   , unitLibraryDynDirs :: [FilePath]+      -- ^ Directories containing the dynamic libraries provided by this unit.+      -- See also `unitLibraryDirs`.+      --+      -- It seems to be used to store paths to external dynamic library+      -- dependencies too.++   , unitExtDepFrameworks :: [String]+      -- ^ Names of the external MacOS frameworks that this unit depends on.++   , unitExtDepFrameworkDirs :: [FilePath]+      -- ^ Directories containing MacOS frameworks that this unit depends+      -- on.++   , unitLinkerOptions  :: [String]+      -- ^ Linker (e.g. ld) command line options++   , unitCcOptions      :: [String]+      -- ^ C compiler options that needs to be passed to the C compiler when we+      -- compile some C code against this unit.++   , unitIncludes       :: [String]+      -- ^ C header files that are required by this unit (provided by this unit+      -- or external)++   , unitIncludeDirs    :: [FilePath]+      -- ^ Directories containing C header files that this unit depends+      -- on.++   , unitHaddockInterfaces :: [FilePath]+      -- ^ Paths to Haddock interface files for this unit++   , unitHaddockHTMLs   :: [FilePath]+      -- ^ Paths to Haddock directories containing HTML files++   , unitExposedModules :: [(modulename, Maybe mod)]+      -- ^ Modules exposed by the unit.+      --+      -- A module can be re-exported from another package. In this case, we+      -- indicate the module origin in the second parameter.++   , unitHiddenModules  :: [modulename]+      -- ^ Hidden modules.+      --+      -- These are useful for error reporting (e.g. if a hidden module is+      -- imported)++   , unitIsIndefinite   :: Bool+      -- ^ True if this unit has some module holes that need to be instantiated+      -- with real modules to make the unit usable (a.k.a. Backpack).++   , unitIsExposed      :: Bool+      -- ^ True if the unit is exposed. A unit could be installed in a database+      -- by "disabled" by not being exposed.++   , unitIsTrusted      :: Bool+      -- ^ True if the unit is trusted (cf Safe Haskell)++   }+   deriving (Eq, Show)++-- | Convert between GenericUnitInfo instances+mapGenericUnitInfo+   :: (uid1 -> uid2)+   -> (cid1 -> cid2)+   -> (srcpkg1 -> srcpkg2)+   -> (srcpkgname1 -> srcpkgname2)+   -> (modname1 -> modname2)+   -> (mod1 -> mod2)+   -> (GenericUnitInfo cid1 srcpkg1 srcpkgname1 uid1 modname1 mod1+       -> GenericUnitInfo cid2 srcpkg2 srcpkgname2 uid2 modname2 mod2)+mapGenericUnitInfo fuid fcid fsrcpkg fsrcpkgname fmodname fmod g@(GenericUnitInfo {..}) =+   g { unitId              = fuid unitId+     , unitInstanceOf      = fcid unitInstanceOf+     , unitInstantiations  = fmap (bimap fmodname fmod) unitInstantiations+     , unitPackageId       = fsrcpkg unitPackageId+     , unitPackageName     = fsrcpkgname unitPackageName+     , unitComponentName   = fmap fsrcpkgname unitComponentName+     , unitDepends         = fmap fuid unitDepends+     , unitAbiDepends      = fmap (first fuid) unitAbiDepends+     , unitExposedModules  = fmap (bimap fmodname (fmap fmod)) unitExposedModules+     , unitHiddenModules   = fmap fmodname unitHiddenModules+     }++-- | @ghc-boot@'s 'Module', serialized to the database.+data DbModule+   = DbModule+      { dbModuleUnitId  :: DbInstUnitId+      , dbModuleName    :: BS.ByteString+      }+   | DbModuleVar+      { dbModuleVarName :: BS.ByteString+      }+   deriving (Eq, Show)++-- | @ghc-boot@'s instantiated unit id, serialized to the database.+data DbInstUnitId++   -- | Instantiated unit+   = DbInstUnitId+      BS.ByteString               -- component id+      [(BS.ByteString, DbModule)] -- instantiations: [(modulename,module)]++   -- | Uninstantiated unit+   | DbUnitId+      BS.ByteString               -- unit id+  deriving (Eq, Show)++-- | Represents a lock of a package db.+newtype PackageDbLock = PackageDbLock Handle++-- | Acquire an exclusive lock related to package DB under given location.+lockPackageDb :: FilePath -> IO PackageDbLock++-- | Release the lock related to package DB.+unlockPackageDb :: PackageDbLock -> IO ()++-- | Acquire a lock of given type related to package DB under given location.+lockPackageDbWith :: LockMode -> FilePath -> IO PackageDbLock+lockPackageDbWith mode file = do+  -- We are trying to open the lock file and then lock it. Thus the lock file+  -- needs to either exist or we need to be able to create it. Ideally we+  -- would not assume that the lock file always exists in advance. When we are+  -- dealing with a package DB where we have write access then if the lock+  -- file does not exist then we can create it by opening the file in+  -- read/write mode. On the other hand if we are dealing with a package DB+  -- where we do not have write access (e.g. a global DB) then we can only+  -- open in read mode, and the lock file had better exist already or we're in+  -- trouble. So for global read-only DBs on platforms where we must lock the+  -- DB for reading then we will require that the installer/packaging has+  -- included the lock file.+  --+  -- Thus the logic here is to first try opening in read-write mode+  -- and if that fails we try read-only (to handle global read-only DBs).+  -- If either succeed then lock the file. IO exceptions (other than the first+  -- open attempt failing due to the file not existing) simply propagate.+  --+  -- Note that there is a complexity here which was discovered in #13945: some+  -- filesystems (e.g. NFS) will only allow exclusive locking if the fd was+  -- opened for write access. We would previously try opening the lockfile for+  -- read-only access first, however this failed when run on such filesystems.+  -- Consequently, we now try read-write access first, falling back to read-only+  -- if we are denied permission (e.g. in the case of a global database).+  catchJust+    (\e -> if isPermissionError e then Just () else Nothing)+    (lockFileOpenIn ReadWriteMode)+    (const $ lockFileOpenIn ReadMode)+  where+    lock = file <.> "lock"++    lockFileOpenIn io_mode = bracketOnError+      (openBinaryFile lock io_mode)+      hClose+      -- If file locking support is not available, ignore the error and proceed+      -- normally. Without it the only thing we lose on non-Windows platforms is+      -- the ability to safely issue concurrent updates to the same package db.+      $ \hnd -> do hLock hnd mode `catch` \FileLockingNotSupported -> return ()+                   return $ PackageDbLock hnd++lockPackageDb = lockPackageDbWith ExclusiveLock+unlockPackageDb (PackageDbLock hnd) = do+    hUnlock hnd+    hClose hnd++-- | Mode to open a package db in.+data DbMode = DbReadOnly | DbReadWrite++-- | 'DbOpenMode' holds a value of type @t@ but only in 'DbReadWrite' mode.  So+-- it is like 'Maybe' but with a type argument for the mode to enforce that the+-- mode is used consistently.+data DbOpenMode (mode :: DbMode) t where+  DbOpenReadOnly  ::      DbOpenMode 'DbReadOnly t+  DbOpenReadWrite :: t -> DbOpenMode 'DbReadWrite t++deriving instance Functor (DbOpenMode mode)+deriving instance F.Foldable (DbOpenMode mode)+deriving instance F.Traversable (DbOpenMode mode)++isDbOpenReadMode :: DbOpenMode mode t -> Bool+isDbOpenReadMode = \case+  DbOpenReadOnly    -> True+  DbOpenReadWrite{} -> False++-- | Read the part of the package DB that GHC is interested in.+--+readPackageDbForGhc :: FilePath -> IO [DbUnitInfo]+readPackageDbForGhc file =+  decodeFromFile file DbOpenReadOnly getDbForGhc >>= \case+    (pkgs, DbOpenReadOnly) -> return pkgs+  where+    getDbForGhc = do+      _version    <- getHeader+      _ghcPartLen <- get :: Get Word32+      ghcPart     <- get+      -- the next part is for ghc-pkg, but we stop here.+      return ghcPart++-- | Read the part of the package DB that ghc-pkg is interested in+--+-- Note that the Binary instance for ghc-pkg's representation of packages+-- is not defined in this package. This is because ghc-pkg uses Cabal types+-- (and Binary instances for these) which this package does not depend on.+--+-- If we open the package db in read only mode, we get its contents. Otherwise+-- we additionally receive a PackageDbLock that represents a lock on the+-- database, so that we can safely update it later.+--+readPackageDbForGhcPkg :: Binary pkgs => FilePath -> DbOpenMode mode t ->+                          IO (pkgs, DbOpenMode mode PackageDbLock)+readPackageDbForGhcPkg file mode =+    decodeFromFile file mode getDbForGhcPkg+  where+    getDbForGhcPkg = do+      _version    <- getHeader+      -- skip over the ghc part+      ghcPartLen  <- get :: Get Word32+      _ghcPart    <- skip (fromIntegral ghcPartLen)+      -- the next part is for ghc-pkg+      ghcPkgPart  <- get+      return ghcPkgPart++-- | Write the whole of the package DB, both parts.+--+writePackageDb :: Binary pkgs => FilePath -> [DbUnitInfo] -> pkgs -> IO ()+writePackageDb file ghcPkgs ghcPkgPart =+  writeFileAtomic file (runPut putDbForGhcPkg)+  where+    putDbForGhcPkg = do+        putHeader+        put               ghcPartLen+        putLazyByteString ghcPart+        put               ghcPkgPart+      where+        ghcPartLen :: Word32+        ghcPartLen = fromIntegral (BS.Lazy.length ghcPart)+        ghcPart    = encode ghcPkgs++getHeader :: Get (Word32, Word32)+getHeader = do+    magic <- getByteString (BS.length headerMagic)+    when (magic /= headerMagic) $+      fail "not a ghc-pkg db file, wrong file magic number"++    majorVersion <- get :: Get Word32+    -- The major version is for incompatible changes++    minorVersion <- get :: Get Word32+    -- The minor version is for compatible extensions++    when (majorVersion /= 1) $+      fail "unsupported ghc-pkg db format version"+    -- If we ever support multiple major versions then we'll have to change+    -- this code++    -- The header can be extended without incrementing the major version,+    -- we ignore fields we don't know about (currently all).+    headerExtraLen <- get :: Get Word32+    skip (fromIntegral headerExtraLen)++    return (majorVersion, minorVersion)++putHeader :: Put+putHeader = do+    putByteString headerMagic+    put majorVersion+    put minorVersion+    put headerExtraLen+  where+    majorVersion   = 1 :: Word32+    minorVersion   = 0 :: Word32+    headerExtraLen = 0 :: Word32++headerMagic :: BS.ByteString+headerMagic = BS.Char8.pack "\0ghcpkg\0"+++-- TODO: we may be able to replace the following with utils from the binary+-- package in future.++-- | Feed a 'Get' decoder with data chunks from a file.+--+decodeFromFile :: FilePath -> DbOpenMode mode t -> Get pkgs ->+                  IO (pkgs, DbOpenMode mode PackageDbLock)+decodeFromFile file mode decoder = case mode of+  DbOpenReadOnly -> do+  -- Note [Locking package database on Windows]+  -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+  -- When we open the package db in read only mode, there is no need to acquire+  -- shared lock on non-Windows platform because we update the database with an+  -- atomic rename, so readers will always see the database in a consistent+  -- state.+#if defined(mingw32_HOST_OS)+    bracket (lockPackageDbWith SharedLock file) unlockPackageDb $ \_ -> do+#endif+      (, DbOpenReadOnly) <$> decodeFileContents+  DbOpenReadWrite{} -> do+    -- When we open the package db in read/write mode, acquire an exclusive lock+    -- on the database and return it so we can keep it for the duration of the+    -- update.+    bracketOnError (lockPackageDb file) unlockPackageDb $ \lock -> do+      (, DbOpenReadWrite lock) <$> decodeFileContents+  where+    decodeFileContents = withBinaryFile file ReadMode $ \hnd ->+      feed hnd (runGetIncremental decoder)++    feed hnd (Partial k)  = do chunk <- BS.hGet hnd BS.Lazy.defaultChunkSize+                               if BS.null chunk+                                 then feed hnd (k Nothing)+                                 else feed hnd (k (Just chunk))+    feed _ (Done _ _ res) = return res+    feed _ (Fail _ _ msg) = ioError err+      where+        err = mkIOError InappropriateType loc Nothing (Just file)+              `ioeSetErrorString` msg+        loc = "GHC.Unit.Database.readPackageDb"++-- Copied from Cabal's Distribution.Simple.Utils.+writeFileAtomic :: FilePath -> BS.Lazy.ByteString -> IO ()+writeFileAtomic targetPath content = do+  let (targetDir, targetFile) = splitFileName targetPath+  Exception.bracketOnError+    (openBinaryTempFileWithDefaultPermissions targetDir $ targetFile <.> "tmp")+    (\(tmpPath, handle) -> hClose handle >> removeFile tmpPath)+    (\(tmpPath, handle) -> do+        BS.Lazy.hPut handle content+        hClose handle+        renameFile tmpPath targetPath)++instance Binary DbUnitInfo where+  put (GenericUnitInfo+         unitId unitInstanceOf unitInstantiations+         unitPackageId+         unitPackageName unitPackageVersion+         unitComponentName+         unitAbiHash unitDepends unitAbiDepends unitImportDirs+         unitLibraries unitExtDepLibsSys unitExtDepLibsGhc+         unitLibraryDirs unitLibraryDynDirs+         unitExtDepFrameworks unitExtDepFrameworkDirs+         unitLinkerOptions unitCcOptions+         unitIncludes unitIncludeDirs+         unitHaddockInterfaces unitHaddockHTMLs+         unitExposedModules unitHiddenModules+         unitIsIndefinite unitIsExposed unitIsTrusted) = do+    put unitPackageId+    put unitPackageName+    put unitPackageVersion+    put unitComponentName+    put unitId+    put unitInstanceOf+    put unitInstantiations+    put unitAbiHash+    put unitDepends+    put unitAbiDepends+    put unitImportDirs+    put unitLibraries+    put unitExtDepLibsSys+    put unitExtDepLibsGhc+    put unitLibraryDirs+    put unitLibraryDynDirs+    put unitExtDepFrameworks+    put unitExtDepFrameworkDirs+    put unitLinkerOptions+    put unitCcOptions+    put unitIncludes+    put unitIncludeDirs+    put unitHaddockInterfaces+    put unitHaddockHTMLs+    put unitExposedModules+    put unitHiddenModules+    put unitIsIndefinite+    put unitIsExposed+    put unitIsTrusted++  get = do+    unitPackageId      <- get+    unitPackageName    <- get+    unitPackageVersion <- get+    unitComponentName  <- get+    unitId             <- get+    unitInstanceOf     <- get+    unitInstantiations <- get+    unitAbiHash        <- get+    unitDepends        <- get+    unitAbiDepends     <- get+    unitImportDirs     <- get+    unitLibraries      <- get+    unitExtDepLibsSys  <- get+    unitExtDepLibsGhc  <- get+    libraryDirs        <- get+    libraryDynDirs     <- get+    frameworks         <- get+    frameworkDirs      <- get+    unitLinkerOptions  <- get+    unitCcOptions      <- get+    unitIncludes       <- get+    unitIncludeDirs    <- get+    unitHaddockInterfaces <- get+    unitHaddockHTMLs   <- get+    unitExposedModules <- get+    unitHiddenModules  <- get+    unitIsIndefinite   <- get+    unitIsExposed      <- get+    unitIsTrusted      <- get+    return (GenericUnitInfo+              unitId+              unitInstanceOf+              unitInstantiations+              unitPackageId+              unitPackageName+              unitPackageVersion+              unitComponentName+              unitAbiHash+              unitDepends+              unitAbiDepends+              unitImportDirs+              unitLibraries unitExtDepLibsSys unitExtDepLibsGhc+              libraryDirs libraryDynDirs+              frameworks frameworkDirs+              unitLinkerOptions unitCcOptions+              unitIncludes unitIncludeDirs+              unitHaddockInterfaces unitHaddockHTMLs+              unitExposedModules+              unitHiddenModules+              unitIsIndefinite unitIsExposed unitIsTrusted)++instance Binary DbModule where+  put (DbModule dbModuleUnitId dbModuleName) = do+    putWord8 0+    put dbModuleUnitId+    put dbModuleName+  put (DbModuleVar dbModuleVarName) = do+    putWord8 1+    put dbModuleVarName+  get = do+    b <- getWord8+    case b of+      0 -> DbModule <$> get <*> get+      _ -> DbModuleVar <$> get++instance Binary DbInstUnitId where+  put (DbUnitId uid) = do+    putWord8 0+    put uid+  put (DbInstUnitId dbUnitIdComponentId dbUnitIdInsts) = do+    putWord8 1+    put dbUnitIdComponentId+    put dbUnitIdInsts++  get = do+    b <- getWord8+    case b of+      0 -> DbUnitId <$> get+      _ -> DbInstUnitId <$> get <*> get+++-- | Return functions to 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).+mkMungePathUrl :: FilePath -> FilePath -> (FilePath -> FilePath, FilePath -> FilePath)+mkMungePathUrl top_dir pkgroot = (munge_path, munge_url)+   where+    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+++-- | 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).+mungeUnitInfoPaths :: FilePath -> FilePath -> GenericUnitInfo a b c d e f -> GenericUnitInfo a b c d e f+mungeUnitInfoPaths top_dir pkgroot pkg =+   -- TODO: similar code is duplicated in utils/ghc-pkg/Main.hs+    pkg+      { unitImportDirs          = munge_paths (unitImportDirs pkg)+      , unitIncludeDirs         = munge_paths (unitIncludeDirs pkg)+      , unitLibraryDirs         = munge_paths (unitLibraryDirs pkg)+      , unitLibraryDynDirs      = munge_paths (unitLibraryDynDirs pkg)+      , unitExtDepFrameworkDirs = munge_paths (unitExtDepFrameworkDirs pkg)+      , unitHaddockInterfaces   = munge_paths (unitHaddockInterfaces pkg)+        -- haddock-html is allowed to be either a URL or a file+      , unitHaddockHTMLs        = munge_paths (munge_urls (unitHaddockHTMLs pkg))+      }+   where+      munge_paths = map munge_path+      munge_urls  = map munge_url+      (munge_path,munge_url) = mkMungePathUrl top_dir pkgroot
libraries/ghci/GHCi/FFI.hsc view
@@ -58,15 +58,29 @@   cif <- mallocBytes (#const sizeof(ffi_cif))   let abi = convToABI cconv   r <- ffi_prep_cif cif abi (fromIntegral n_args) (ffiType result_type) arg_arr-  if (r /= fFI_OK)-     then throwIO (ErrorCall ("prepForeignCallFailed: " ++ show r))-     else return (castPtr cif)+  if r /= fFI_OK then+    throwIO $ ErrorCall $ concat+      [ "prepForeignCallFailed: ", strError r,+        "(cconv: ", show cconv,+        " arg tys: ", show arg_types,+        " res ty: ", show result_type, ")" ]+  else+    return (castPtr cif)  freeForeignCallInfo :: Ptr C_ffi_cif -> IO () freeForeignCallInfo p = do   free ((#ptr ffi_cif, arg_types) p)   free p +strError :: C_ffi_status -> String+strError r+  | r == fFI_BAD_ABI+  = "invalid ABI (FFI_BAD_ABI)"+  | r == fFI_BAD_TYPEDEF+  = "invalid type description (FFI_BAD_TYPEDEF)"+  | otherwise+  = "unknown error: " ++ show r+ convToABI :: FFIConv -> C_ffi_abi convToABI FFICCall  = fFI_DEFAULT_ABI #if defined(mingw32_HOST_OS) && defined(i386_HOST_ARCH)@@ -108,12 +122,10 @@ foreign import ccall "&ffi_type_double" ffi_type_double  :: Ptr C_ffi_type foreign import ccall "&ffi_type_pointer"ffi_type_pointer :: Ptr C_ffi_type -fFI_OK            :: C_ffi_status-fFI_OK            = (#const FFI_OK)---fFI_BAD_ABI     :: C_ffi_status---fFI_BAD_ABI     = (#const FFI_BAD_ABI)---fFI_BAD_TYPEDEF :: C_ffi_status---fFI_BAD_TYPEDEF = (#const FFI_BAD_TYPEDEF)+fFI_OK, fFI_BAD_ABI, fFI_BAD_TYPEDEF :: C_ffi_status+fFI_OK = (#const FFI_OK)+fFI_BAD_ABI = (#const FFI_BAD_ABI)+fFI_BAD_TYPEDEF = (#const FFI_BAD_TYPEDEF)  fFI_DEFAULT_ABI :: C_ffi_abi fFI_DEFAULT_ABI = (#const FFI_DEFAULT_ABI)
libraries/template-haskell/Language/Haskell/TH/Syntax.hs view
@@ -45,12 +45,15 @@ import GHC.Types        ( Int(..), Word(..), Char(..), Double(..), Float(..),                           TYPE, RuntimeRep(..) ) import GHC.Prim         ( Int#, Word#, Char#, Double#, Float#, Addr# )+import GHC.Ptr          ( Ptr, plusPtr ) import GHC.Lexeme       ( startsVarSym, startsVarId ) import GHC.ForeignSrcLang.Type import Language.Haskell.TH.LanguageExtensions import Numeric.Natural import Prelude import Foreign.ForeignPtr+import Foreign.C.String+import Foreign.C.Types  ----------------------------------------------------- --@@ -122,8 +125,7 @@ -----------------------------------------------------  instance Quasi IO where-  qNewName s = do { n <- atomicModifyIORef' counter (\x -> (x + 1, x))-                  ; pure (mkNameU s n) }+  qNewName = newNameIO    qReport True  msg = hPutStrLn stderr ("Template Haskell error: " ++ msg)   qReport False msg = hPutStrLn stderr ("Template Haskell error: " ++ msg)@@ -150,6 +152,13 @@   qIsExtEnabled _       = badIO "isExtEnabled"   qExtsEnabled          = badIO "extsEnabled" +instance Quote IO where+  newName = newNameIO++newNameIO :: String -> IO Name+newNameIO s = do { n <- atomicModifyIORef' counter (\x -> (x + 1, x))+                 ; pure (mkNameU s n) }+ badIO :: String -> IO a badIO op = do   { qReport True ("Can't do `" ++ op ++ "' in the IO monad")                 ; fail "Template Haskell failure" }@@ -849,7 +858,7 @@   lift xs = do { xs' <- mapM lift xs; return (ListE xs') }  liftString :: Quote m => String -> m Exp--- Used in TcExpr to short-circuit the lifting for strings+-- Used in GHC.Tc.Gen.Expr to short-circuit the lifting for strings liftString s = return (LitE (StringL s))  -- | @since 2.15.0.0@@ -1598,7 +1607,7 @@     prefix     = "unboxedSumDataName: "     debug_info = " (alt: " ++ show alt ++ ", arity: " ++ show arity ++ ")" -    -- Synced with the definition of mkSumDataConOcc in TysWiredIn+    -- Synced with the definition of mkSumDataConOcc in GHC.Builtin.Types     sum_occ = '(' : '#' : bars nbars_before ++ '_' : bars nbars_after ++ "#)"     bars i = replicate i '|'     nbars_before = alt - 1@@ -1614,7 +1623,7 @@          (NameG TcClsName (mkPkgName "ghc-prim") (mkModName "GHC.Prim"))    where-    -- Synced with the definition of mkSumTyConOcc in TysWiredIn+    -- Synced with the definition of mkSumTyConOcc in GHC.Builtin.Types     sum_occ = '(' : '#' : replicate (arity - 1) '|' ++ "#)"  -----------------------------------------------------@@ -1868,7 +1877,45 @@    -- , bytesInitialized :: Bool -- ^ False: only use `bytesSize` to allocate    --                            --   an uninitialized region    }-   deriving (Eq,Ord,Data,Generic,Show)+   deriving (Data,Generic)++-- We can't derive Show instance for Bytes because we don't want to show the+-- pointer value but the actual bytes (similarly to what ByteString does). See+-- #16457.+instance Show Bytes where+   show b = unsafePerformIO $ withForeignPtr (bytesPtr b) $ \ptr ->+               peekCStringLen ( ptr `plusPtr` fromIntegral (bytesOffset b)+                              , fromIntegral (bytesSize b)+                              )++-- We can't derive Eq and Ord instances for Bytes because we don't want to+-- compare pointer values but the actual bytes (similarly to what ByteString+-- does).  See #16457+instance Eq Bytes where+   (==) = eqBytes++instance Ord Bytes where+   compare = compareBytes++eqBytes :: Bytes -> Bytes -> Bool+eqBytes a@(Bytes fp off len) b@(Bytes fp' off' len')+  | len /= len'              = False    -- short cut on length+  | fp == fp' && off == off' = True     -- short cut for the same bytes+  | otherwise                = compareBytes a b == EQ++compareBytes :: Bytes -> Bytes -> Ordering+compareBytes (Bytes _   _    0)    (Bytes _   _    0)    = EQ  -- short cut for empty Bytes+compareBytes (Bytes fp1 off1 len1) (Bytes fp2 off2 len2) =+    unsafePerformIO $+      withForeignPtr fp1 $ \p1 ->+      withForeignPtr fp2 $ \p2 -> do+        i <- memcmp (p1 `plusPtr` fromIntegral off1)+                    (p2 `plusPtr` fromIntegral off2)+                    (fromIntegral (min len1 len2))+        return $! (i `compare` 0) <> (len1 `compare` len2)++foreign import ccall unsafe "memcmp"+  memcmp :: Ptr a -> Ptr b -> CSize -> IO CInt   -- | Pattern in Haskell given in @{}@